Merge branch 'main' of https://huggingface.co/spaces/ansysresearch/quantum

app.py

@@ -46,15 +46,18 @@ state.logo_src = _load_logo_data_uri()
 # --- Import Embedded Modules ---
 # These are lightweight modules that build UI without creating their own servers
 import qlbm_embedded
-import em_embedded
+import em  # Use the modular em package instead of em_embedded
 
 # Set the shared server on both modules
 qlbm_embedded.set_server(server)
-em_embedded.set_server(server)
+em.set_server(server)
 
 # Initialize state for both modules
 qlbm_embedded.init_state()
-em_embedded.init_state()
+em.init_state()
+
+# Register EM handlers (must be done after server binding)
+em.register_handlers()
 
 # --- Build the Layout ---
 with SinglePageLayout(server) as layout:
@@ -168,7 +171,7 @@ with SinglePageLayout(server) as layout:
             fluid=True,
             classes="pa-0 fill-height",
         ):
-            em_embedded.build_ui()
+            em.build_ui()
         
         # === QLBM Experience ===
         with vuetify3.VContainer(
@@ -178,18 +181,33 @@ with SinglePageLayout(server) as layout:
         ):
             qlbm_embedded.build_ui()
 
+# Enable point picking after UI is built (prevents KeyError with Trame state)
+em.enable_point_picking_on_plotter()
+
 # --- Heartbeat for HuggingFace ---
 def _start_hf_heartbeat_thread(interval_s: int = 5):
     """Keep the WebSocket alive for HuggingFace Spaces."""
+    import asyncio
+    
     def _loop():
         while True:
             time.sleep(interval_s)
             try:
-                server.controller.flush()
+                # Create a new event loop for this thread if needed
+                try:
+                    loop = asyncio.get_event_loop()
+                except RuntimeError:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                
+                # Try to flush, but don't crash if it fails
+                if hasattr(server, 'controller') and hasattr(server.controller, 'flush'):
+                    server.controller.flush()
             except Exception:
-                break
+                # Silently continue - heartbeat is optional
+                pass
     
-    t = threading.Thread(target=_loop, daemon=True)
+    t = threading.Thread(target=_loop, daemon=True, name="HeartbeatThread")
     t.start()
 
 # --- Entry Point ---

app_old.py

@@ -1,239 +0,0 @@
-import os
-# Ensure OMP_NUM_THREADS is set to avoid libgomp errors
-os.environ["OMP_NUM_THREADS"] = "1"
-
-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
-import threading
-from concurrent.futures import ThreadPoolExecutor
-import time
-
-# Import embedded page wrappers (lazy load inside tabs)
-from importlib import import_module
-em_page = None
-qlbm_page = None
-
-# Force embedded mode for nested pages (avoid iframes/secondary servers)
-os.environ.setdefault("TRAME_EMBEDDED", "1")
-os.environ.setdefault("TRAME_DISABLE_BROWSER", "1")
-os.environ.setdefault("EM_APP_EMBEDDED", "1")
-os.environ.setdefault("DISABLE_EM_STANDALONE", "1")
-
-# Create a single server for the multipage app
-server = get_server()
-state, ctrl = server.state, server.controller
-
-# App state: landing chooser -> specific experience
-state.current_page = None  # "EM" or "QLBM" once selected
-
-# -------------------------------------------------------------------------
-# Thread pool for long-running jobs to avoid UI freezing by HF timeout
-# -------------------------------------------------------------------------
-MAX_WORKERS = int(os.environ.get("MAX_WORKERS", "4"))
-executor = ThreadPoolExecutor(max_workers=MAX_WORKERS)
-
-def submit_background(fn, *args, **kwargs):
-    """
-    Run a CPU-heavy / long job without blocking Trame's event loop.
-
-    Usage from pages:
-        from trame.app import get_server
-        server = get_server()
-        server.submit_background(long_fn, arg1, arg2, kw1=...)
-    """
-    return executor.submit(fn, *args, **kwargs)
-
-# Expose helper on the server so pages.em_page / pages.qlbm_page can use it
-server.submit_background = submit_background
-
-# Load Synopsys/Ansys logo as data URI for main toolbar
-import base64
-
-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"),
-    ]
-    for p in candidates:
-        if os.path.exists(p):
-            ext = os.path.splitext(p)[1].lower()
-            mime = "image/svg+xml" if ext == ".svg" else ("image/png" if ext == ".png" else "image/jpeg")
-            with open(p, "rb") as f:
-                b64 = base64.b64encode(f.read()).decode("ascii")
-            return f"data:{mime};base64,{b64}"
-    return None
-
-def _stop_subapp(module_name: str, attr_name: str):
-    module = globals().get(attr_name)
-    if module is None:
-        try:
-            module = import_module(module_name)
-            globals()[attr_name] = module
-        except Exception:
-            return
-    stop_fn = getattr(module, "stop", None)
-    if callable(stop_fn):
-        try:
-            stop_fn()
-        except Exception:
-            pass
-
-
-# Safely initialize logo in state (trame state isn't a dict; avoid .get())
-try:
-    if not hasattr(state, "logo_src") or state.logo_src in (None, ""):
-        state.logo_src = _load_logo_data_uri()
-except Exception:
-    state.logo_src = _load_logo_data_uri()
-
-
-@state.change("current_page")
-def _handle_page_change(current_page, **_):
-    """Stop inactive subprocesses as users navigate between experiences."""
-    if current_page == "EM":
-        _stop_subapp("pages.qlbm_page", "qlbm_page")
-    elif current_page == "QLBM":
-        _stop_subapp("pages.em_page", "em_page")
-    else:
-        _stop_subapp("pages.em_page", "em_page")
-        _stop_subapp("pages.qlbm_page", "qlbm_page")
-
-with SinglePageLayout(server) as layout:
-    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;"
-
-    with layout.toolbar:
-        vuetify3.VSpacer()
-        vuetify3.VBtn(
-            v_if="current_page",
-            text="Main Page",
-            variant="text",
-            color="primary",
-            prepend_icon="mdi-arrow-left",
-            click="current_page = null",
-            classes="mr-2",
-        )
-        vuetify3.VChip(
-            v_if="current_page",
-            label=True,
-            color="primary",
-            text_color="white",
-            children=["{{ current_page === 'EM' ? 'Electromagnetic Scattering' : 'Quantum LBM' }}"],
-            classes="mr-2",
-        )
-        vuetify3.VImg(
-            v_if="logo_src",
-            src=("logo_src", None),
-            style="height: 40px; width: auto;",
-            classes="ml-2",
-        )
-
-    with layout.content:
-        # Landing screen
-        with vuetify3.VContainer(
-            v_if="!current_page",
-            fluid=True,
-            classes="fill-height d-flex align-center justify-center pa-6",
-        ):
-            with vuetify3.VSheet(
-                elevation=6,
-                rounded=True,
-                style="max-width: 1080px; width: 100%; background: linear-gradient(135deg, #fdfbff, #f3ecff);",
-                classes="pa-8",
-            ):
-                vuetify3.VCardTitle(
-                    "Pick a quantum experience",
-                    classes="text-h4 text-primary font-weight-bold mb-2 text-center",
-                )
-                vuetify3.VCardSubtitle(
-                    "Choose one workflow. We'll spin up only that server until you switch back.",
-                    classes="text-body-1 text-center mb-6",
-                )
-                with vuetify3.VRow(justify="center", align="stretch", class_="text-left"):
-                    with vuetify3.VCol(cols=12, md=5, class_="d-flex"):
-                        with vuetify3.VCard(elevation=4, classes="pa-6 flex-grow-1"):
-                            vuetify3.VIcon("mdi-radar", size=52, color="primary", classes="mb-4")
-                            vuetify3.VCardTitle("Electromagnetic Scattering", classes="text-h5 mb-2")
-                            vuetify3.VCardText(
-                                "Placeholder",
-                                classes="text-body-2 mb-6",
-                            )
-                            vuetify3.VBtn(
-                                text="Launch EM",
-                                color="primary",
-                                block=True,
-                                prepend_icon="mdi-play-circle",
-                                size="large",
-                                click="current_page = 'EM'",
-                            )
-                    with vuetify3.VCol(cols=12, md=5, class_="d-flex"):
-                        with vuetify3.VCard(elevation=4, classes="pa-6 flex-grow-1"):
-                            vuetify3.VIcon("mdi-water", size=52, color="secondary", classes="mb-4")
-                            vuetify3.VCardTitle("Fluids", classes="text-h5 mb-2")
-                            vuetify3.VCardText(
-                                "Placeholder",
-                                classes="text-body-2 mb-6",
-                            )
-                            vuetify3.VBtn(
-                                text="Launch QLBM",
-                                color="secondary",
-                                block=True,
-                                prepend_icon="mdi-play-circle",
-                                size="large",
-                                click="current_page = 'QLBM'",
-                            )
-
-        # EM experience
-        with vuetify3.VContainer(v_if="current_page === 'EM'", fluid=True, classes="pa-0 fill-height"):
-            try:
-                if not globals().get("em_page"):
-                    globals()["em_page"] = import_module("pages.em_page")
-                em_page.build(server)
-            except Exception as e:
-                trame_html.Div(f"EM embed failed: {e}", style="padding:8px;color:#b00020;")
-
-        # QLBM experience
-        with vuetify3.VContainer(v_if="current_page === 'QLBM'", fluid=True, classes="pa-0 fill-height"):
-            try:
-                if not globals().get("qlbm_page"):
-                    globals()["qlbm_page"] = import_module("pages.qlbm_page")
-                qlbm_page.build(server)
-            except Exception as e:
-                trame_html.Div(f"QLBM embed failed: {e}", style="padding:8px;color:#b00020;")
-
-# -------------------------------------------------------------------------
-# Heartbeat: keep HuggingFace WebSocket alive during idle periods
-# -------------------------------------------------------------------------
-def _start_hf_heartbeat_thread(interval_s: int = 5):
-    """
-    Start a background thread that periodically flushes the server,
-    keeping the WebSocket "active" in the eyes of Hugging Face.
-    """
-    def _loop():
-        while True:
-            time.sleep(interval_s)
-            try:
-                server.controller.flush()
-            except Exception:
-                # If server is shutting down or flush fails, exit the thread
-                break
-
-    t = threading.Thread(target=_loop, daemon=True)
-    t.start()
-
-
-if __name__ == "__main__":
-
-    # Start HF heartbeat to prevent timeout
-    _start_hf_heartbeat_thread(interval_s=5)
-
-    # Allow reverse-proxy setups to pin the internal host/port independently from the public PORT
-    port = int(os.environ.get("APP_PORT") or os.environ.get("PORT", 7860))
-    host = os.environ.get("APP_HOST", "0.0.0.0")
-    server.start(host=host, port=port, open_browser=False)

delta_impulse_generator.py

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

em/__init__.py

@@ -0,0 +1,145 @@
+"""
+EM Embedded Package
+
+Modular Electromagnetic Scattering Simulation Module for Trame.
+
+This package provides a modular structure for the EM simulation application,
+designed for embedded use in a shared Trame server.
+
+Usage:
+    from em import set_server, init_state, build_ui
+    
+    # After creating a server
+    set_server(server)
+    init_state()
+    
+    # In your layout
+    with layout.content:
+        build_ui()
+"""
+
+# Import core components from submodules
+from .state import (
+    state, 
+    ctrl, 
+    set_server, 
+    init_state,
+    get_server,
+    enable_point_picking_on_plotter,
+)
+
+from .globals import (
+    plotter,
+    GRID_SIZES,
+    DEFAULT_AXIS_TICKS,
+    EXCITATION_SURFACE_COLORSCALE,
+    qpu_ts_cache,
+    sim_ts_cache,
+)
+
+from .simulation import (
+    run_simulation_only,
+    reset_to_defaults,
+    stop_simulation_handler,
+    add_dotted_unit_grid,
+    add_dotted_unit_grid_scaled,
+    build_sim_timeseries_plotly,
+    update_value_display,
+)
+
+from .geometry import (
+    update_geometry_preview,
+    update_geometry_hole_preview,
+    compute_hole_edges as _compute_hole_edges,
+    build_geometry_placeholder as _build_geometry_placeholder,
+    build_square_domain_plot as _build_square_domain_plot,
+)
+
+from .excitation import (
+    update_initial_state_preview,
+    build_excitation_placeholder as _build_excitation_placeholder,
+    build_excitation_surface_plot as _build_excitation_surface_plot,
+)
+
+from .qpu import (
+    build_qpu_timeseries_plotly_multi,
+    rebuild_qpu_fig_filtered as _rebuild_qpu_fig_filtered,
+    rebuild_qpu_fig_others as _rebuild_qpu_fig_others,
+    refresh_qpu_plot_figures as _refresh_qpu_plot_figures,
+    qpu_add_monitor_config,
+    qpu_remove_monitor_config,
+    qpu_set_plot_filter,
+    qpu_set_plot_position_filter,
+    qpu_add_monitor_slot,
+    qpu_remove_monitor_slot,
+)
+
+from .exports import (
+    export_vtk,
+    export_vtk_all_frames,
+    export_mp4,
+    export_sim_timeseries_csv,
+    export_sim_timeseries_png,
+    export_sim_timeseries_html,
+    export_qpu_timeseries_csv,
+    export_qpu_timeseries_png,
+    export_qpu_timeseries_html,
+)
+
+from .handlers import (
+    register_handlers,
+    build_qubit_plot,
+    _determine_workflow_step,
+    _apply_workflow_highlights,
+)
+
+from .utils import (
+    load_logo_data_uri,
+    install_synopsys_plotly_theme,
+)
+
+from .ui import build_ui
+
+# Install the Synopsys Plotly theme at module load time
+install_synopsys_plotly_theme()
+
+__all__ = [
+    # Core API
+    "state",
+    "ctrl", 
+    "set_server",
+    "init_state",
+    "build_ui",
+    
+    # Simulation
+    "run_simulation_only",
+    "reset_to_defaults",
+    "stop_simulation_handler",
+    
+    # Previews
+    "update_initial_state_preview",
+    "update_geometry_preview",
+    "update_geometry_hole_preview",
+    
+    # QPU
+    "qpu_ts_cache",
+    "build_qpu_timeseries_plotly_multi",
+    
+    # Exports
+    "export_vtk",
+    "export_vtk_all_frames", 
+    "export_mp4",
+    "export_qpu_timeseries_csv",
+    "export_qpu_timeseries_png",
+    "export_qpu_timeseries_html",
+    "export_sim_timeseries_csv",
+    "export_sim_timeseries_png",
+    "export_sim_timeseries_html",
+    
+    # Handlers
+    "register_handlers",
+    
+    # Globals
+    "plotter",
+    "GRID_SIZES",
+]

em/excitation.py

@@ -0,0 +1,538 @@
+"""
+EM Embedded - Excitation Module
+
+Contains excitation preview builders and update functions.
+"""
+import numpy as np
+import pyvista as pv
+import plotly.graph_objects as go
+
+from .state import state, ctrl
+from .globals import (
+    plotter, current_mesh, DEFAULT_AXIS_TICKS, EXCITATION_SURFACE_COLORSCALE
+)
+from .utils import SAMPLE_PAIR_RE
+
+# Import simulation callback for point picking
+def _get_update_value_display():
+    """Lazy import to avoid circular dependency."""
+    from .simulation import update_value_display
+    return update_value_display
+
+# Import backend functions
+try:
+    from quantum.utils.delta_impulse_generator import create_impulse_state, create_gaussian_state
+except ModuleNotFoundError:
+    from utils.delta_impulse_generator import create_impulse_state, create_gaussian_state
+
+__all__ = [
+    "build_excitation_placeholder",
+    "build_excitation_surface_plot",
+    "push_excitation_plot",
+    "update_initial_state_preview",
+    "nearest_node_index",
+    "snap_samples_to_grid",
+    "update_sim_monitor_points",
+    "update_qpu_sample_slot",
+    "hide_qpu_plots",
+    "update_excitation_info_message",
+]
+
+
+def nearest_node_index(x: float, y: float, nx: int, ny: int = None) -> tuple:
+    """Map normalized [0,1] coordinates to nearest node index on an nx×ny grid."""
+    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_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 = float(getattr(state, 'peak_x', 0.5))
+            y_in = float(getattr(state, 'peak_y', 0.5))
+        elif state.dist_type == "Gaussian":
+            x_in = float(getattr(state, 'mu_x', 0.5))
+            y_in = float(getattr(state, 'mu_y', 0.5))
+        else:
+            state.excitation_info_message = ""
+            return
+
+        ix, iy = nearest_node_index(x_in, y_in, nx)
+        x_snapped, y_snapped = ix / denom, iy / denom
+        changed = (
+            abs(x_in - x_snapped) > 1e-9
+            or abs(y_in - y_snapped) > 1e-9
+        )
+        descriptor = "adjusted" if changed else "aligned"
+        state.excitation_info_message = (
+            f"Input ({x_in:.3f}, {y_in:.3f}) {descriptor} to nearest Position "
+            f"({x_snapped:.3f}, {y_snapped:.3f})."
+        )
+    except Exception:
+        state.excitation_info_message = ""
+
+
+def build_excitation_placeholder(message: str = "Select an excitation to preview.") -> go.Figure:
+    """Build a placeholder figure for excitation preview."""
+    fig = go.Figure()
+    fig.add_annotation(
+        text=message, 
+        x=0.5, 
+        y=0.5, 
+        showarrow=False, 
+        font=dict(size=18, color="#5F259F")
+    )
+    fig.update_xaxes(visible=False)
+    fig.update_yaxes(visible=False)
+    fig.update_layout(
+        template="plotly_white",
+        margin=dict(l=20, r=20, t=40, b=20),
+        paper_bgcolor="#ffffff",
+        plot_bgcolor="#ffffff",
+        height=520,
+        showlegend=False,
+    )
+    return fig
+
+
+def build_excitation_surface_plot(
+    X: np.ndarray,
+    Y: np.ndarray,
+    field: np.ndarray,
+    title: str,
+    *,
+    show_grid_lines: bool = False,
+    grid_line_resolution: int = None,
+) -> go.Figure:
+    """Build a 3D surface plot for excitation preview."""
+    max_abs = float(np.max(np.abs(field))) if field.size else 1.0
+    if max_abs < 1e-12:
+        max_abs = 1.0
+    height_scale = 0.1
+    Z = (field / max_abs) * height_scale
+    fig = go.Figure()
+
+    fig.add_trace(
+        go.Surface(
+            x=X,
+            y=Y,
+            z=Z,
+            surfacecolor=field,
+            colorscale=EXCITATION_SURFACE_COLORSCALE,
+            cmin=-max_abs,
+            cmax=max_abs,
+            showscale=False,
+            opacity=0.98,
+            lighting=dict(ambient=0.6, diffuse=0.6, specular=0.15),
+            hovertemplate="x=%{x:.3f}<br>y=%{y:.3f}<br>z=%{z:.3f}<extra></extra>",
+        )
+    )
+
+    x_vals = np.unique(np.round(X[0], decimals=6))
+    y_vals = np.unique(np.round(Y[:, 0], decimals=6))
+    x_min, x_max = float(np.min(x_vals)), float(np.max(x_vals))
+    y_min, y_max = float(np.min(y_vals)), float(np.max(y_vals))
+    base_z = -0.02
+
+    if show_grid_lines:
+        span_x = x_max - x_min if x_max != x_min else 1.0
+        span_y = y_max - y_min if y_max != y_min else 1.0
+        if grid_line_resolution is not None and grid_line_resolution >= 2:
+            res = int(grid_line_resolution)
+            norm_vals = np.linspace(0.0, 1.0, res)
+        else:
+            norm_vals = np.asarray(DEFAULT_AXIS_TICKS)
+        x_grid_vals = x_min + span_x * norm_vals
+        y_grid_vals = y_min + span_y * norm_vals
+
+        line_x, line_y, line_z = [], [], []
+        for val in x_grid_vals:
+            val_f = float(val)
+            line_x.extend([val_f, val_f, np.nan])
+            line_y.extend([y_min, y_max, np.nan])
+            line_z.extend([base_z, base_z, np.nan])
+        for val in y_grid_vals:
+            val_f = float(val)
+            line_x.extend([x_min, x_max, np.nan])
+            line_y.extend([val_f, val_f, np.nan])
+            line_z.extend([base_z, base_z, np.nan])
+
+        fig.add_trace(
+            go.Scatter3d(
+                x=line_x,
+                y=line_y,
+                z=line_z,
+                mode="lines",
+                line=dict(color="rgba(174,139,216,0.3)", width=1),
+                showlegend=False,
+                hoverinfo="skip",
+            )
+        )
+
+        tick_positions_x = x_min + span_x * np.asarray(DEFAULT_AXIS_TICKS)
+        tick_positions_y = y_min + span_y * np.asarray(DEFAULT_AXIS_TICKS)
+        tick_labels = [f"{t:.2f}" for t in DEFAULT_AXIS_TICKS]
+        x_offset = x_min - 0.03 * span_x
+        y_offset = y_min - 0.03 * span_y
+        tick_plane = base_z - 0.01
+        fig.add_trace(
+            go.Scatter3d(
+                x=tick_positions_x,
+                y=[y_offset] * len(tick_positions_x),
+                z=[tick_plane] * len(tick_positions_x),
+                mode="text",
+                text=tick_labels,
+                textfont=dict(color="#5F259F", size=12),
+                showlegend=False,
+                hoverinfo="skip",
+            )
+        )
+        fig.add_trace(
+            go.Scatter3d(
+                x=[x_offset] * len(tick_positions_y),
+                y=tick_positions_y,
+                z=[tick_plane] * len(tick_positions_y),
+                mode="text",
+                text=tick_labels,
+                textfont=dict(color="#5F259F", size=12),
+                showlegend=False,
+                hoverinfo="skip",
+            )
+        )
+
+    # Domain boundary
+    fig.add_trace(
+        go.Scatter3d(
+            x=[x_min, x_max, x_max, x_min, x_min],
+            y=[y_min, y_min, y_max, y_max, y_min],
+            z=[base_z - 0.005] * 5,
+            mode="lines",
+            line=dict(color="rgba(255,192,203,0.9)", width=2.5),
+            showlegend=False,
+            hoverinfo="skip",
+        )
+    )
+
+    pad_x = 0.05 * (x_max - x_min if x_max != x_min else 1.0)
+    pad_y = 0.05 * (y_max - y_min if y_max != y_min else 1.0)
+
+    fig.update_layout(
+        title=title,
+        margin=dict(l=10, r=10, t=36, b=10),
+        height=620,
+        template="plotly_white",
+        scene=dict(
+            xaxis=dict(range=[x_min - pad_x, x_max + pad_x], showgrid=False, showline=False, showticklabels=False, zeroline=False, visible=False, showbackground=False),
+            yaxis=dict(range=[y_min - pad_y, y_max + pad_y], showgrid=False, showline=False, showticklabels=False, zeroline=False, visible=False, showbackground=False),
+            zaxis=dict(range=[-0.3, 0.3], showgrid=False, showline=False, showticklabels=False, zeroline=False, visible=False, showbackground=False),
+            aspectmode="cube",
+            camera=dict(eye=dict(x=1.2, y=1.2, z=1.0)),
+        ),
+        dragmode="orbit",
+        uirevision="excitation_surface",
+    )
+    return fig
+
+
+def push_excitation_plot(fig: go.Figure = None):
+    """Push an excitation plot to the UI."""
+    render_fig = fig or build_excitation_placeholder()
+    try:
+        if hasattr(ctrl, "excitation_preview_update"):
+            ctrl.excitation_preview_update(render_fig)
+    except Exception:
+        pass
+
+
+def _refresh_pyvista_view():
+    """Refresh the PyVista view."""
+    try:
+        if hasattr(ctrl, "view_update"):
+            ctrl.view_update()
+    except Exception:
+        pass
+
+
+def snap_samples_to_grid(sample_str: str, nx: int) -> tuple:
+    """
+    Convert normalized sample positions to nearest integer grid indices.
+    
+    Returns:
+        tuple: (grid_points_string, message)
+    """
+    if not sample_str or not str(sample_str).strip():
+        return "", ""
+    matches = SAMPLE_PAIR_RE.findall(str(sample_str))
+    if not matches:
+        return "", "Enter sample position(s) as (x, y) pairs in [0,1] x [0,1]."
+
+    nx_int = int(nx)
+    denom = float(max(nx_int - 1, 1))
+    tokens = []
+    info_lines = []
+    
+    def _normalize_value(val: float) -> float:
+        threshold = 1.0 + 1e-9
+        if abs(val) <= threshold:
+            return max(0.0, min(1.0, val))
+        max_index = float(nx_int - 1)
+        return max(0.0, min(max_index, val)) / denom if denom else 0.0
+    
+    for raw_x, raw_y in matches:
+        try:
+            x_val = float(raw_x)
+            y_val = float(raw_y)
+        except ValueError:
+            continue
+        x_norm = _normalize_value(x_val)
+        y_norm = _normalize_value(y_val)
+        ix, iy = nearest_node_index(x_norm, y_norm, nx_int)
+        tokens.append(f"({ix}, {iy})")
+        snapped_x = ix / denom
+        snapped_y = iy / denom
+        changed = (
+            abs(x_norm - snapped_x) > 1e-9
+            or abs(y_norm - snapped_y) > 1e-9
+        )
+        descriptor = "adjusted" if changed else "aligned"
+        info_lines.append(
+            f"Input ({x_val:.3f}, {y_val:.3f}) {descriptor} to nearest Position ({snapped_x:.3f}, {snapped_y:.3f})."
+        )
+    
+    grid_str = ", ".join(tokens)
+    message = "\n".join(info_lines)
+    return grid_str, message
+
+
+def update_sim_monitor_points():
+    """Update simulator monitor points based on state."""
+    sample_value = state.timeseries_points
+    if not sample_value or not str(sample_value).strip():
+        state.timeseries_gridpoints = ""
+        state.timeseries_point_info = ""
+        return
+    nx_val = state.nx
+    if nx_val is None:
+        state.timeseries_gridpoints = ""
+        state.timeseries_point_info = "Select a grid size (nx) to compute the nearest monitor positions."
+        return
+    snapped, message = snap_samples_to_grid(sample_value, int(nx_val))
+    state.timeseries_gridpoints = snapped
+    state.timeseries_point_info = message or ""
+
+
+def update_qpu_sample_slot(slot_index: int):
+    """Update QPU sample slot based on state."""
+    suffix = "" if slot_index == 1 else f"_{slot_index}"
+    sample_attr = f"qpu_monitor_samples{suffix}"
+    grid_attr = f"qpu_monitor_gridpoints{suffix}"
+    info_attr = f"qpu_monitor_sample_info{suffix}"
+    sample_value = getattr(state, sample_attr, "")
+    nx_val = state.nx
+    if not sample_value or not str(sample_value).strip():
+        setattr(state, grid_attr, "")
+        setattr(state, info_attr, "")
+        return
+    if nx_val is None:
+        setattr(state, info_attr, "Select a grid size (nx) to compute the nearest grid position.")
+        setattr(state, grid_attr, "")
+        return
+    snapped, message = snap_samples_to_grid(sample_value, int(nx_val))
+    setattr(state, grid_attr, snapped)
+    setattr(state, info_attr, message or "")
+    if state.backend_type == "QPU":
+        hide_qpu_plots()
+
+
+def hide_qpu_plots():
+    """Hide QPU plots."""
+    state.qpu_ts_ready = False
+    state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+    state.qpu_ts_other_ready = False
+    state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+    state.qpu_plot_position_options = ["All positions"]
+    state.qpu_plot_position_filter = "All positions"
+
+
+def update_initial_state_preview():
+    """
+    Update the initial state preview based on current geometry and excitation settings.
+    This is the main preview function called when state changes.
+    """
+    from .geometry import (
+        build_geometry_placeholder, push_geometry_plot,
+        update_geometry_preview, update_geometry_hole_preview
+    )
+    
+    global current_mesh
+    
+    # Don't render any preview while running
+    if state.is_running:
+        plotter.clear()
+        _refresh_pyvista_view()
+        return
+    
+    # If no geometry selected, clear and stop
+    if not state.geometry_selection:
+        plotter.clear()
+        push_geometry_plot(build_geometry_placeholder("Select a geometry to preview."))
+        push_excitation_plot(None)
+        _refresh_pyvista_view()
+        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()
+            push_excitation_plot(None)
+            return
+        if state.geometry_selection == "Square Metallic Body":
+            update_geometry_hole_preview()
+            push_excitation_plot(None)
+            return
+        push_geometry_plot(build_geometry_placeholder("Preview not available for this geometry yet."))
+        push_excitation_plot(None)
+        return
+
+    # Plotly preview for excitation surface before any simulation run
+    if not state.simulation_has_run:
+        plotter.clear()
+        state.error_message = ""
+        preview_n = 128
+        nx_sel = state.nx
+        try:
+            slider_n = None
+            if nx_sel is not None:
+                slider_n = int(nx_sel)
+            grid_n = slider_n if slider_n is not None else preview_n
+            if slider_n is None:
+                show_grid_lines = True
+                grid_line_resolution = None
+            else:
+                show_grid_lines = True
+                grid_line_resolution = max(slider_n, 2)
+            grid_n = max(grid_n, 8)
+            
+            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))
+                title = "Delta Excitation"
+            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))
+                title = "Gaussian Excitation"
+            else:
+                push_excitation_plot(None)
+                _refresh_pyvista_view()
+                return
+
+            initial_grid = full_state[: grid_n * grid_n].reshape(grid_n, grid_n)
+            denom = float(max(grid_n - 1, 1))
+            coords = np.arange(grid_n) / denom
+            X, Y = np.meshgrid(coords, coords)
+            fig = build_excitation_surface_plot(
+                X,
+                Y,
+                initial_grid,
+                f"{title} (nx={grid_n})",
+                show_grid_lines=show_grid_lines,
+                grid_line_resolution=grid_line_resolution,
+            )
+            push_excitation_plot(fig)
+        except ValueError as e:
+            state.error_message = f"Parameter Error: {e}"
+            push_excitation_plot(build_excitation_placeholder("Check excitation parameters."))
+        except Exception as e:
+            state.error_message = f"An unexpected error occurred: {e}"
+            push_excitation_plot(build_excitation_placeholder("Unable to render preview."))
+        finally:
+            _refresh_pyvista_view()
+        return
+
+    # PyVista preview after simulation has run
+    plotter.clear()
+    state.error_message = ""
+    preview_n = 128
+    nx_sel = state.nx
+    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
+        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()
+
+        plotter.add_mesh(
+            mesh,
+            scalars='scalars',
+            cmap="Blues",
+            show_scalar_bar=False,
+            show_edges=show_grid_edges,
+            edge_color='grey',
+            line_width=0.5,
+        )
+        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",
+        )
+        plotter.add_axes()
+        plotter.view_isometric()
+        # Enable point picking for coordinate display
+        try:
+            plotter.disable_picking()
+        except Exception:
+            pass
+        try:
+            plotter.enable_point_picking(callback=_get_update_value_display(), show_message=False)
+        except Exception:
+            pass
+        try:
+            plotter.camera.parallel_projection = True
+        except Exception:
+            pass
+        _refresh_pyvista_view()
+
+    except ValueError as e:
+        state.error_message = f"Parameter Error: {e}"
+    except Exception as e:
+        state.error_message = f"An unexpected error occurred: {e}"

em/exports.py

@@ -0,0 +1,386 @@
+"""Export functions for VTK, MP4, CSV, PNG, and HTML output."""
+from __future__ import annotations
+
+import base64
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pyvista as pv
+import plotly.graph_objects as go
+
+from .state import state, _server
+from .globals import (
+    plotter, simulation_data, current_mesh,
+    surface_clims, data_frames, X_grids, Y_grids, z_scale, snapshot_times,
+    qpu_ts_cache, sim_ts_cache,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Surface / VTK Exports
+# ---------------------------------------------------------------------------
+
+def export_vtk():
+    """Export current surface mesh to user's Downloads as .vtp and notify via snackbar."""
+    if current_mesh is None:
+        state.export_status_message = "No mesh to export."
+        state.show_export_status = True
+        return
+    try:
+        field = state.surface_field or "Ez"
+        nx = int(state.nx or 16)
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"surface_{field}_nx{nx}_{suffix}.vtp"
+        
+        # Write to a temporary file first
+        with tempfile.NamedTemporaryFile(suffix=".vtp", delete=False) as tmp:
+            current_mesh.save(tmp.name)
+            content = Path(tmp.name).read_bytes()
+            # Encode content as base64 for browser download
+            content_b64 = base64.b64encode(content).decode("ascii")
+            # Trigger browser download via JavaScript
+            if _server is not None:
+                _server.js_call("utils", "download", filename, f"data:application/octet-stream;base64,{content_b64}")
+            Path(tmp.name).unlink()  # Clean up
+
+        state.export_status_message = f"Exported VTK to {filename}"
+    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 zip file."""
+    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.")
+
+        nx = int(state.nx or 16)
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        zip_filename = f"vtk_sequence_{field}_nx{nx}_{suffix}.zip"
+        
+        import zipfile
+        
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+            temp_zip_path = tmp_zip.name
+            
+        with zipfile.ZipFile(temp_zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            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"
+                
+                with tempfile.NamedTemporaryFile(suffix=".vtp", delete=False) as tmp_vtp:
+                    tmp_vtp_path = tmp_vtp.name
+                
+                mesh.save(tmp_vtp_path)
+                zf.write(tmp_vtp_path, arcname=fname)
+                Path(tmp_vtp_path).unlink()
+
+        content = Path(temp_zip_path).read_bytes()
+        content_b64 = base64.b64encode(content).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", zip_filename, f"data:application/zip;base64,{content_b64}")
+        Path(temp_zip_path).unlink()
+
+        state.export_status_message = f"Exported {len(frames)} frames to {zip_filename}"
+    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."""
+    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.")
+
+        nx = int(state.nx or 16)
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"surface_anim_{field}_nx{nx}_{suffix}.mp4"
+
+        # Create a temporary file for the MP4
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
+            temp_path = tmp.name
+
+        # 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.get(field)
+        Y = Y_grids.get(field)
+        if X is None or Y is None:
+            raise ValueError(f"Grid data not available for {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.get(field, (-1, 1)),
+            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(temp_path, framerate=20)
+        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.get(field, (-1, 1)),
+                    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()
+
+        # Read the file content and trigger download
+        content = Path(temp_path).read_bytes()
+        content_b64 = base64.b64encode(content).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:video/mp4;base64,{content_b64}")
+        Path(temp_path).unlink()  # Clean up
+
+        state.export_status_message = f"Exported MP4 to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+
+# ---------------------------------------------------------------------------
+# Simulator Time-Series Exports
+# ---------------------------------------------------------------------------
+
+def export_sim_timeseries_csv():
+    """Export Simulator time-series to CSV."""
+    try:
+        times = sim_ts_cache.get("times")
+        series_map = sim_ts_cache.get("series_map")
+        if not times or not series_map:
+            state.export_status_message = "No Simulator time series data to export."
+            state.show_export_status = True
+            return
+        
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"sim_timeseries_{suffix}.csv"
+        
+        # Build CSV content
+        lines = ["time"]
+        keys = list(series_map.keys())
+        for k in keys:
+            field, px, py = k
+            lines[0] += f",{field}_({px},{py})"
+        
+        for i, t in enumerate(times):
+            row = [str(t)]
+            for k in keys:
+                vals = series_map.get(k, [])
+                row.append(str(vals[i]) if i < len(vals) else "")
+            lines.append(",".join(row))
+        
+        content = "\n".join(lines)
+        content_b64 = base64.b64encode(content.encode("utf-8")).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:text/csv;base64,{content_b64}")
+        
+        state.export_status_message = f"Exported CSV to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+
+def export_sim_timeseries_png():
+    """Export Simulator time-series plot to PNG."""
+    try:
+        fig = sim_ts_cache.get("figure")
+        if fig is None:
+            state.export_status_message = "No Simulator time series figure to export."
+            state.show_export_status = True
+            return
+        
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"sim_timeseries_{suffix}.png"
+        
+        # Export to PNG
+        content = fig.to_image(format="png", width=1200, height=800)
+        content_b64 = base64.b64encode(content).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:image/png;base64,{content_b64}")
+        
+        state.export_status_message = f"Exported PNG to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+
+def export_sim_timeseries_html():
+    """Export Simulator time-series plot to interactive HTML."""
+    try:
+        fig = sim_ts_cache.get("figure")
+        if fig is None:
+            state.export_status_message = "No Simulator time series figure to export."
+            state.show_export_status = True
+            return
+        
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"sim_timeseries_{suffix}.html"
+        
+        # Export to HTML
+        content = fig.to_html(include_plotlyjs="cdn", full_html=True)
+        content_b64 = base64.b64encode(content.encode("utf-8")).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:text/html;base64,{content_b64}")
+        
+        state.export_status_message = f"Exported HTML to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+
+# ---------------------------------------------------------------------------
+# QPU Time-Series Exports
+# ---------------------------------------------------------------------------
+
+def export_qpu_timeseries_csv():
+    """Export QPU time-series to CSV."""
+    try:
+        times = qpu_ts_cache.get("times")
+        series_map = qpu_ts_cache.get("series_map")
+        if not times or not series_map:
+            state.export_status_message = "No QPU time series data to export."
+            state.show_export_status = True
+            return
+        
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"qpu_timeseries_{suffix}.csv"
+        
+        # Build CSV content
+        lines = ["time"]
+        keys = list(series_map.keys())
+        for k in keys:
+            field, px, py = k
+            lines[0] += f",{field}_({px},{py})"
+        
+        for i, t in enumerate(times):
+            row = [str(t)]
+            for k in keys:
+                vals = series_map.get(k, [])
+                row.append(str(vals[i]) if i < len(vals) else "")
+            lines.append(",".join(row))
+        
+        content = "\n".join(lines)
+        content_b64 = base64.b64encode(content.encode("utf-8")).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:text/csv;base64,{content_b64}")
+        
+        state.export_status_message = f"Exported CSV to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+
+def export_qpu_timeseries_png():
+    """Export QPU time-series plot to PNG."""
+    try:
+        fig = qpu_ts_cache.get("figure")
+        if fig is None:
+            state.export_status_message = "No QPU time series figure to export."
+            state.show_export_status = True
+            return
+        
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"qpu_timeseries_{suffix}.png"
+        
+        # Export to PNG
+        content = fig.to_image(format="png", width=1200, height=800)
+        content_b64 = base64.b64encode(content).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:image/png;base64,{content_b64}")
+        
+        state.export_status_message = f"Exported PNG to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+
+def export_qpu_timeseries_html():
+    """Export QPU time-series plot to interactive HTML."""
+    try:
+        fig = qpu_ts_cache.get("figure")
+        if fig is None:
+            state.export_status_message = "No QPU time series figure to export."
+            state.show_export_status = True
+            return
+        
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"qpu_timeseries_{suffix}.html"
+        
+        # Export to HTML
+        content = fig.to_html(include_plotlyjs="cdn", full_html=True)
+        content_b64 = base64.b64encode(content.encode("utf-8")).decode("ascii")
+        if _server is not None:
+            _server.js_call("utils", "download", filename, f"data:text/html;base64,{content_b64}")
+        
+        state.export_status_message = f"Exported HTML to {filename}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True

em/geometry.py

@@ -0,0 +1,306 @@
+"""
+EM Embedded - Geometry Module
+
+Contains geometry preview builders and hole computation functions.
+"""
+import numpy as np
+import plotly.graph_objects as go
+
+from .state import state, ctrl
+from .globals import DEFAULT_AXIS_TICKS, EXCITATION_SURFACE_COLORSCALE
+
+__all__ = [
+    "nearest_gridline",
+    "compute_hole_edges",
+    "build_geometry_placeholder",
+    "build_square_domain_plot",
+    "push_geometry_plot",
+    "update_geometry_preview",
+    "update_geometry_hole_preview",
+]
+
+
+def nearest_gridline(val: float, nx: int) -> float:
+    """Snap a value to the nearest gridline."""
+    denom = float(max(int(nx) - 1, 1))
+    return round(float(val) * denom) / denom
+
+
+def compute_hole_edges(nx: int, cx: float, cy: float, a: float, snap: bool = True):
+    """
+    Compute square hole edges (xL, xR, yB, yT) in [0,1].
+
+    Args:
+        nx: points per direction; grid lines at k/(nx-1).
+        cx, cy: center in (0,1).
+        a: edge length in (0,1].
+        snap: if True, snap edges to nearest grid lines; else require exact alignment.
+
+    Returns:
+        tuple (xL, xR, yB, yT) or None when invalid/out-of-bounds/misaligned.
+    """
+    try:
+        nx = int(nx)
+        cx = float(cx)
+        cy = float(cy)
+        a = float(a)
+    except Exception:
+        return None
+
+    if not (a > 0.0):
+        return None
+
+    half = a / 2.0
+    xL, xR = cx - half, cx + half
+    yB, yT = cy - half, cy + half
+
+    # Must be strictly inside domain to allow removing interior cells safely
+    if not (0.0 < xL < xR < 1.0 and 0.0 < yB < yT < 1.0):
+        return None
+
+    if snap:
+        xL_s = nearest_gridline(xL, nx)
+        xR_s = nearest_gridline(xR, nx)
+        yB_s = nearest_gridline(yB, nx)
+        yT_s = nearest_gridline(yT, nx)
+        # Ensure non-degenerate after snapping; attempt a minimal adjustment if equal
+        if xL_s >= xR_s or yB_s >= yT_s:
+            step = 1.0 / float(max(nx - 1, 1))
+            if xL_s >= xR_s:
+                if xL_s - step > 0.0:
+                    xL_s -= step
+                elif xR_s + step < 1.0:
+                    xR_s += step
+            if yB_s >= yT_s:
+                if yB_s - step > 0.0:
+                    yB_s -= step
+                elif yT_s + step < 1.0:
+                    yT_s += step
+            if xL_s >= xR_s or yB_s >= yT_s:
+                return None
+        return (xL_s, xR_s, yB_s, yT_s)
+    else:
+        # Require edges to already lie on grid lines
+        denom = float(max(nx - 1, 1))
+        tol = 1e-9
+        def _aligned(v: float) -> bool:
+            return abs(v * denom - round(v * denom)) < tol
+        if all(_aligned(v) for v in (xL, xR, yB, yT)):
+            return (xL, xR, yB, yT)
+        return None
+
+
+def build_geometry_placeholder(message: str) -> go.Figure:
+    """Build a placeholder figure with a message."""
+    fig = go.Figure()
+    fig.add_annotation(
+        text=message,
+        x=0.5,
+        y=0.5,
+        showarrow=False,
+        font=dict(size=18, color="#5F259F"),
+    )
+    fig.update_xaxes(visible=False)
+    fig.update_yaxes(visible=False)
+    fig.update_layout(
+        template="plotly_white",
+        margin=dict(l=20, r=20, t=40, b=20),
+        paper_bgcolor="#ffffff",
+        plot_bgcolor="#ffffff",
+        height=460,
+        showlegend=False,
+    )
+    return fig
+
+
+def build_square_domain_plot(
+    nx: int,
+    title: str,
+    hole_edges=None,
+    *,
+    show_edges: bool = True,
+    dense_grid: bool = False,
+) -> go.Figure:
+    """Build a 3D square domain plot with optional hole."""
+    nx = max(int(nx), 3)
+    grid = np.linspace(0.0, 1.0, nx)
+    X, Y = np.meshgrid(grid, grid, indexing="xy")
+    Z = np.zeros_like(X, dtype=float)
+    color_field = np.full_like(Z, 0.85)
+
+    if hole_edges is not None:
+        xL, xR, yB, yT = hole_edges
+        mask = (X >= xL) & (X <= xR) & (Y >= yB) & (Y <= yT)
+        Z = np.where(mask, np.nan, Z)
+        color_field = np.where(mask, np.nan, color_field)
+
+    fig = go.Figure()
+    fig.add_trace(
+        go.Surface(
+            x=X,
+            y=Y,
+            z=Z,
+            surfacecolor=np.where(np.isnan(color_field), 0.15, color_field),
+            colorscale=EXCITATION_SURFACE_COLORSCALE,
+            cmin=0.0,
+            cmax=1.0,
+            showscale=False,
+            opacity=0.98,
+            lighting=dict(ambient=0.85, diffuse=0.55, specular=0.1),
+            hovertemplate="x=%{x:.3f}<br>y=%{y:.3f}<extra></extra>",
+        )
+    )
+
+    if show_edges:
+        base_z = -0.012
+        grid_vals = (
+            np.linspace(0.0, 1.0, max(int(nx), 2))
+            if dense_grid
+            else np.asarray(DEFAULT_AXIS_TICKS)
+        )
+        line_x, line_y, line_z = [], [], []
+        x_min_val, x_max_val = float(grid[0]), float(grid[-1])
+        for val in grid_vals:
+            val_f = float(val)
+            line_x.extend([val_f, val_f, np.nan])
+            line_y.extend([x_min_val, x_max_val, np.nan])
+            line_z.extend([base_z, base_z, np.nan])
+        for val in grid_vals:
+            val_f = float(val)
+            line_x.extend([x_min_val, x_max_val, np.nan])
+            line_y.extend([val_f, val_f, np.nan])
+            line_z.extend([base_z, base_z, np.nan])
+        fig.add_trace(
+            go.Scatter3d(
+                x=line_x,
+                y=line_y,
+                z=line_z,
+                mode="lines",
+                line=dict(color="rgba(174,139,216,0.65)", width=1.6),
+                showlegend=False,
+                hoverinfo="skip",
+            )
+        )
+
+    scale_ticks = list(DEFAULT_AXIS_TICKS)
+    tick_text = [f"{t:.2f}" for t in scale_ticks]
+    tick_plane = -0.02
+    fig.add_trace(
+        go.Scatter3d(
+            x=scale_ticks,
+            y=[-0.018] * len(scale_ticks),
+            z=[tick_plane] * len(scale_ticks),
+            mode="text",
+            text=tick_text,
+            textfont=dict(color="#5F259F", size=12),
+            showlegend=False,
+            hoverinfo="skip",
+        )
+    )
+    fig.add_trace(
+        go.Scatter3d(
+            x=[-0.018] * len(scale_ticks),
+            y=scale_ticks,
+            z=[tick_plane] * len(scale_ticks),
+            mode="text",
+            text=tick_text,
+            textfont=dict(color="#5F259F", size=12),
+            showlegend=False,
+            hoverinfo="skip",
+        )
+    )
+
+    if hole_edges is not None:
+        xL, xR, yB, yT = hole_edges
+        fig.add_trace(
+            go.Scatter3d(
+                x=[xL, xR, xR, xL, xL],
+                y=[yB, yB, yT, yT, yB],
+                z=[0.0] * 5,
+                mode="lines",
+                line=dict(color="#FFFFFF", width=5),
+                hoverinfo="skip",
+                showlegend=False,
+            )
+        )
+
+    fig.update_layout(
+        title=title,
+        margin=dict(l=8, r=8, t=44, b=8),
+        height=620,
+        template="plotly_white",
+        scene=dict(
+            xaxis=dict(range=[-0.05, 1.05], visible=False, backgroundcolor="#f7f3ff"),
+            yaxis=dict(range=[-0.05, 1.05], visible=False, backgroundcolor="#f7f3ff"),
+            zaxis=dict(range=[0.1, 0.1], visible=False, backgroundcolor="#f7f3ff"),
+            aspectmode="cube",
+            camera=dict(eye=dict(x=1.25, y=1.25, z=0.85)),
+        ),
+        dragmode="orbit",
+        uirevision="geometry_surface",
+    )
+    return fig
+
+
+def push_geometry_plot(fig: go.Figure):
+    """Push a geometry plot to the UI."""
+    try:
+        if hasattr(ctrl, "geometry_preview_update"):
+            ctrl.geometry_preview_update(fig)
+    except Exception:
+        pass
+
+
+def update_geometry_preview():
+    """Update the geometry preview based on current state."""
+    if not state.bound:
+        return
+    
+    geo = state.geometry_selection
+    if geo in (None, "None"):
+        fig = build_geometry_placeholder("Select a geometry to preview.")
+    elif geo == "Square Domain":
+        nx = int(state.nx or 16)
+        fig = build_square_domain_plot(nx, "Square Domain Preview", None, show_edges=True)
+    elif geo == "Square Metallic Body":
+        nx = int(state.nx or 16)
+        # Use hole parameters from state
+        edges = compute_hole_edges(
+            nx,
+            float(state.hole_center_x or 0.5),
+            float(state.hole_center_y or 0.5),
+            float(state.hole_size_edge or 0.2),
+            snap=getattr(state, "hole_snap", True),
+        )
+        fig = build_square_domain_plot(nx, "Square Metallic Body Preview", edges, show_edges=True)
+    else:
+        fig = build_geometry_placeholder(f"Geometry: {geo}")
+    
+    push_geometry_plot(fig)
+
+
+def update_geometry_hole_preview():
+    """Update geometry preview with current hole settings."""
+    if not state.bound:
+        return
+    
+    geo = state.geometry_selection
+    if geo != "Square Metallic Body":
+        return
+    
+    nx = int(state.nx or 16)
+    edges = compute_hole_edges(
+        nx,
+        float(state.hole_center_x or 0.5),
+        float(state.hole_center_y or 0.5),
+        float(state.hole_size_edge or 0.2),
+        snap=getattr(state, "hole_snap", True),
+    )
+    
+    if edges is None:
+        state.hole_error_message = "Invalid hole configuration (edges out of bounds or degenerate)"
+    else:
+        state.hole_error_message = ""
+    
+    fig = build_square_domain_plot(nx, "Square Metallic Body Preview", edges, show_edges=True)
+    push_geometry_plot(fig)

em/globals.py

@@ -0,0 +1,107 @@
+"""
+EM Embedded - Global Variables and Constants
+
+Contains PyVista plotter, simulation data, caches, and constants
+shared across the EM module.
+"""
+import numpy as np
+import pyvista as pv
+
+# Set PyVista to use off-screen rendering for Trame
+pv.OFF_SCREEN = True
+
+__all__ = [
+    "plotter",
+    "simulation_data",
+    "current_mesh", 
+    "data_frames",
+    "X_grids",
+    "Y_grids",
+    "surface_clims",
+    "stop_simulation",
+    "snapshot_times",
+    "z_scale",
+    "GRID_SIZES",
+    "DEFAULT_AXIS_TICKS",
+    "EXCITATION_SURFACE_COLORSCALE",
+    "qpu_ts_cache",
+    "sim_ts_cache",
+    "qpu_cfg_id_counter",
+]
+
+# --- Constants ---
+GRID_SIZES = ["16", "32", "64", "128", "256", "512"]
+DEFAULT_AXIS_TICKS = (0.0, 0.25, 0.5, 0.75, 1.0)
+
+EXCITATION_SURFACE_COLORSCALE = [
+    [0.0, "#001219"],
+    [0.25, "#005F73"],
+    [0.5, "#94D2BD"],
+    [0.75, "#EE9B00"],
+    [1.0, "#CA6702"],
+]
+
+# --- PyVista and Simulation Data ---
+plotter = pv.Plotter()
+simulation_data = None
+current_mesh = None
+data_frames = None
+z_scale = 1.0
+X_grids = {}  # Dictionary: field -> meshgrid X
+Y_grids = {}  # Dictionary: field -> meshgrid Y
+surface_clims = {}
+stop_simulation = False  # Flag to stop running simulation
+snapshot_times = None    # Times corresponding to saved frames
+
+# --- Caches ---
+# Cache for QPU Plotly export/selection
+qpu_ts_cache = {
+    "times": None,
+    "series_map": None,
+    "field": None,
+    "fig": None,
+    "positions_by_field": {"All": []},
+    "key_to_label": {},
+    "label_to_keys": {},
+    "nx": None,
+    "unique_fields": [],
+}
+
+# Cache for Simulator Time Series
+sim_ts_cache = {
+    "fig": None,
+    "field": None,
+}
+
+# Stable id generator for QPU monitor config rows
+qpu_cfg_id_counter = 1
+
+
+def new_monitor_cfg(field: str = "Ez", points: str = "(8, 8)") -> dict:
+    """Create a new QPU monitor configuration."""
+    global qpu_cfg_id_counter
+    cfg = {"id": qpu_cfg_id_counter, "field": field, "points": points}
+    qpu_cfg_id_counter += 1
+    return cfg
+
+
+def reset_globals():
+    """Reset global simulation state."""
+    global simulation_data, current_mesh, data_frames, X_grids, Y_grids
+    global surface_clims, stop_simulation, snapshot_times, z_scale
+    
+    simulation_data = None
+    current_mesh = None
+    data_frames = None
+    X_grids = {}
+    Y_grids = {}
+    surface_clims = {}
+    stop_simulation = False
+    snapshot_times = None
+    z_scale = 1.0
+
+
+def set_stop_simulation(value: bool):
+    """Set the stop simulation flag."""
+    global stop_simulation
+    stop_simulation = value

em/handlers.py

@@ -0,0 +1,423 @@
+"""State change handlers for the EM module.
+
+All @state.change decorated functions that respond to UI state changes.
+"""
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .state import state, ctrl
+from .geometry import compute_hole_edges as _compute_hole_edges, update_geometry_hole_preview
+from .excitation import update_initial_state_preview, update_excitation_info_message
+from .qpu import (
+    update_qpu_sample_slot as _update_qpu_sample_slot,
+    refresh_all_qpu_sample_slots as _refresh_all_qpu_sample_slots,
+    hide_qpu_plots as _hide_qpu_plots,
+)
+from .simulation import update_sim_monitor_points as _update_sim_monitor_points
+
+if TYPE_CHECKING:
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Workflow Highlights (visual feedback for UI cards)
+# ---------------------------------------------------------------------------
+
+def _determine_workflow_step() -> int:
+    """Determine which configuration step the user is on (1-6)."""
+    try:
+        if not state.problem_selection:
+            return 1
+        if not state.geometry_selection:
+            return 2
+        if not state.dist_type:
+            return 3
+        nx = state.nx
+        if nx is None:
+            return 4
+        if not state.backend_type:
+            return 5
+        return 6
+    except Exception:
+        return 1
+
+
+def _apply_workflow_highlights(step: int):
+    """Set card styles based on current workflow step."""
+    try:
+        base_style = "font-size: 0.8rem;"
+        highlight = "font-size: 0.8rem; border: 2px solid #5F259F; box-shadow: 0 0 8px rgba(95,37,159,0.25);"
+        state.overview_card_style = highlight if step == 1 else base_style
+        state.geometry_card_style = highlight if step == 2 else base_style
+        state.excitation_card_style = highlight if step == 3 else base_style
+        state.meshing_card_style = highlight if step == 4 else base_style
+        state.backend_card_style = highlight if step == 5 else base_style
+        state.output_card_style = highlight if step == 6 else base_style
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Qubit Plot (meshing slider)
+# ---------------------------------------------------------------------------
+
+def build_qubit_plot(grid_size: int):
+    """Build a Plotly figure showing qubit requirements vs grid size."""
+    import numpy as np
+    import plotly.graph_objects as go
+    
+    x_sizes = np.array([16, 32, 64, 128, 256, 512])
+    y_qubits = 2 * np.ceil(np.log2(x_sizes)).astype(int) + 4
+    current_nq = int(2 * np.ceil(np.log2(max(1, int(grid_size)))) + 4)
+
+    fig = go.Figure()
+    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
+
+
+# ---------------------------------------------------------------------------
+# State Change Handlers - Registered after server binding
+# ---------------------------------------------------------------------------
+
+def register_handlers():
+    """Register all @state.change handlers. Call after server is bound."""
+    if not state.bound:
+        return
+
+    @state.change("nx")
+    def update_qubit_plot_handler(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
+        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 not mode_snap and edges is None:
+            state.hole_error_message = "Hole edges must align with grid lines; enable Snap to auto-align."
+            return
+
+        # Inputs valid; clear error and refresh preview
+        state.hole_error_message = ""
+        update_geometry_hole_preview()
+
+    @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))
+            state.hole_error_message = ""
+        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()
+            _apply_workflow_highlights(_determine_workflow_step())
+            return
+        update_excitation_info_message()
+        _apply_workflow_highlights(_determine_workflow_step())
+
+    @state.change("qpu_monitor_samples")
+    def on_qpu_monitor_samples_change(**kwargs):
+        _update_qpu_sample_slot(1)
+
+    @state.change("qpu_monitor_samples_2")
+    def on_qpu_monitor_samples_2_change(**kwargs):
+        _update_qpu_sample_slot(2)
+
+    @state.change("qpu_monitor_samples_3")
+    def on_qpu_monitor_samples_3_change(**kwargs):
+        _update_qpu_sample_slot(3)
+
+    @state.change("qpu_monitor_samples_4")
+    def on_qpu_monitor_samples_4_change(**kwargs):
+        _update_qpu_sample_slot(4)
+
+    @state.change("qpu_monitor_samples_5")
+    def on_qpu_monitor_samples_5_change(**kwargs):
+        _update_qpu_sample_slot(5)
+
+    @state.change("nx")
+    def on_nx_change_refresh_qpu_samples(nx, **kwargs):
+        _refresh_all_qpu_sample_slots()
+        _update_sim_monitor_points()
+        _apply_workflow_highlights(_determine_workflow_step())
+
+    @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 = ""
+
+    @state.change("backend_type")
+    def on_backend_change(backend_type, **kwargs):
+        if backend_type == "QPU":
+            _hide_qpu_plots()
+        _apply_workflow_highlights(_determine_workflow_step())
+
+    @state.change("selected_qpu")
+    def on_selected_qpu_change(selected_qpu, **kwargs):
+        if state.backend_type == "QPU":
+            _hide_qpu_plots()
+
+    @state.change("qpu_plot_filter")
+    def on_qpu_plot_filter_change(qpu_plot_filter, **kwargs):
+        # No-op: updates handled by controller bound to the VSelect to avoid double refresh
+        return
+
+    @state.change("problem_selection")
+    def on_problem_change(problem_selection, **kwargs):
+        """Update geometry options based on problem selection."""
+        # Filter geometry options based on problem
+        if problem_selection == "Propagation in a given medium (no bodies)":
+            # Hide "Square Metallic Body" for propagation problem
+            state.geometry_options = ["None", "Square Domain", "Geometry 2", "Add"]
+        elif problem_selection == "Scattering from a perfectly conducting body":
+            # Hide "Square Domain" for scattering problem
+            state.geometry_options = ["None", "Square Metallic Body", "Geometry 2", "Add"]
+        else:
+            # Show all options when no problem selected
+            state.geometry_options = ["None", "Square Metallic Body", "Square Domain", "Geometry 2", "Add"]
+        
+        # Reset geometry selection if current selection is no longer valid
+        if state.geometry_selection not in state.geometry_options:
+            state.geometry_selection = None
+        
+        _apply_workflow_highlights(_determine_workflow_step())
+
+    @state.change("geometry_selection")
+    def on_geometry_change(geometry_selection, **kwargs):
+        _apply_workflow_highlights(_determine_workflow_step())
+
+    @state.change("peak_pair")
+    def sync_peak_pair(peak_pair, **kwargs):
+        """Parse peak pair (x, y) and validate."""
+        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 = float(m.group(1))
+            y = float(m.group(2))
+            if not (0.0 <= x <= 1.0) or not (0.0 <= y <= 1.0):
+                state.excitation_error_message = "Peak must be in [0,1]."
+                return
+            state.peak_x = x
+            state.peak_y = y
+            state.excitation_error_message = ""
+            update_initial_state_preview()
+        except Exception:
+            state.excitation_error_message = "Invalid peak. Use format (x, y)."
+
+    @state.change("mu_pair")
+    def sync_mu_pair(mu_pair, **kwargs):
+        """Parse mu pair (x, y) and validate."""
+        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 = float(m.group(1))
+            y = float(m.group(2))
+            if not (0.0 <= x <= 1.0) or not (0.0 <= y <= 1.0):
+                state.excitation_error_message = "Mu must be in [0,1]."
+                return
+            state.mu_x = x
+            state.mu_y = y
+            state.excitation_error_message = ""
+            update_initial_state_preview()
+        except Exception:
+            state.excitation_error_message = "Invalid mu. Use format (x, y)."
+
+    @state.change("sigma_x", "sigma_y")
+    def on_sigma_change(sigma_x, sigma_y, **kwargs):
+        update_initial_state_preview()
+
+    # -----------------------------------------------------------------------
+    # Additional handlers for simulation workflow
+    # -----------------------------------------------------------------------
+
+    @state.change("nx_slider_index")
+    def on_slider_index_change(nx_slider_index, **kwargs):
+        """Handle grid size slider changes."""
+        from .globals import GRID_SIZES
+        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):
+        """Handle changes to input parameters."""
+        from .simulation import generate_plot
+        
+        if state.is_running:
+            return
+
+        update_excitation_info_message()
+
+        if state.backend_type == "QPU":
+            state.qpu_ts_ready = False
+            state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            state.qpu_ts_other_ready = False
+            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+
+        changed_keys = set(kwargs.keys())
+
+        if state.simulation_has_run:
+            state.run_button_text = "Re-run!"
+            return
+
+        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):
+        """Handle changes to output configuration."""
+        from .simulation import generate_plot
+        _update_sim_monitor_points()
+        if state.simulation_has_run:
+            generate_plot()
+
+    @state.change("timeseries_points")
+    def on_timeseries_points_text_change(**kwargs):
+        """Handle changes to timeseries points text."""
+        _update_sim_monitor_points()
+
+    @state.change("surface_field")
+    def on_surface_field_change(surface_field, **kwargs):
+        """Handle changes to surface field selection."""
+        from .simulation import redraw_surface_plot
+        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):
+        """Handle changes to time value."""
+        from .simulation import redraw_surface_plot
+        if not state.simulation_has_run or state.output_type != "Surface Plot":
+            return
+        redraw_surface_plot()
+
+    @state.change("geometry_selection")
+    def handle_geometry_add(geometry_selection, **kwargs):
+        """Handle geometry selection changes."""
+        if geometry_selection in (None, "", "None"):
+            state.geometry_selection = None
+            update_initial_state_preview()
+            _apply_workflow_highlights(_determine_workflow_step())
+            return
+        if geometry_selection == "Add":
+            state.show_upload_dialog = True
+            state.geometry_selection = None
+            _apply_workflow_highlights(_determine_workflow_step())
+            return
+        update_initial_state_preview()
+        _apply_workflow_highlights(_determine_workflow_step())
+
+    @state.change("uploaded_file_info")
+    def handle_file_upload(uploaded_file_info, **kwargs):
+        """Handle file upload completion."""
+        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

em/qpu.py

@@ -0,0 +1,657 @@
+"""
+EM Embedded - QPU Module
+
+Contains QPU timeseries, caching, filters, and handlers.
+"""
+import re
+import numpy as np
+import plotly.graph_objects as go
+from collections import defaultdict
+from matplotlib import cm as _mpl_cm
+
+from .state import state, ctrl
+from .globals import qpu_ts_cache
+from .utils import normalized_position_label, format_grid_label
+
+# Import backend functions
+try:
+    from quantum.utils.delta_impulse_generator import create_time_frames, run_qpu
+    import quantum.utils.delta_impulse_generator as qutils
+except ModuleNotFoundError:
+    from utils.delta_impulse_generator import create_time_frames, run_qpu
+    import utils.delta_impulse_generator as qutils
+
+__all__ = [
+    "cmap_for_field",
+    "update_qpu_position_options",
+    "filter_series_keys",
+    "refresh_qpu_plot_figures",
+    "build_qpu_timeseries_plotly_multi",
+    "rebuild_qpu_fig_filtered",
+    "rebuild_qpu_fig_others",
+    "on_qpu_ts_click",
+    "on_qpu_ts_clear",
+    "qpu_add_monitor_config",
+    "qpu_remove_monitor_config",
+    "qpu_set_monitor_field",
+    "qpu_set_monitor_points",
+    "qpu_set_plot_filter",
+    "qpu_set_plot_position_filter",
+    "qpu_add_monitor_slot",
+    "qpu_remove_monitor_slot",
+    # Internal functions needed by handlers
+    "hide_qpu_plots",
+    "update_qpu_sample_slot",
+    "refresh_all_qpu_sample_slots",
+]
+
+
+def hide_qpu_plots():
+    """Hide QPU timeseries plots."""
+    state.qpu_ts_ready = False
+    state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+    state.qpu_ts_other_ready = False
+    state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+    state.qpu_plot_position_options = ["All positions"]
+    state.qpu_plot_position_filter = "All positions"
+
+
+def update_qpu_sample_slot(slot: int):
+    """Update QPU sample slot with grid point info."""
+    try:
+        samples_var = f"qpu_monitor_samples{'_' + str(slot) if slot > 1 else ''}"
+        info_var = f"qpu_monitor_sample_info{'_' + str(slot) if slot > 1 else ''}"
+        gp_var = f"qpu_monitor_gridpoints{'_' + str(slot) if slot > 1 else ''}"
+        
+        samples = getattr(state, samples_var, "")
+        nx = int(state.nx or 16)
+        
+        if not samples:
+            setattr(state, info_var, "")
+            setattr(state, gp_var, "")
+            return
+            
+        # Parse sample pairs
+        pairs = re.findall(r'\(\s*([-+]?\d*\.?\d+)\s*,\s*([-+]?\d*\.?\d+)\s*\)', str(samples))
+        if not pairs:
+            setattr(state, info_var, "Invalid format. Use (x, y).")
+            setattr(state, gp_var, "")
+            return
+            
+        gps = []
+        labels = []
+        for x_str, y_str in pairs:
+            x = float(x_str)
+            y = float(y_str)
+            i = int(round(x * (nx - 1)))
+            j = int(round(y * (nx - 1)))
+            i = max(0, min(nx - 1, i))
+            j = max(0, min(nx - 1, j))
+            gps.append((i, j))
+            labels.append(f"({i}, {j})")
+            
+        setattr(state, gp_var, "; ".join(labels))
+        setattr(state, info_var, f"Grid points: {', '.join(labels)}")
+    except Exception:
+        pass
+
+
+def refresh_all_qpu_sample_slots():
+    """Refresh all QPU sample slots."""
+    for slot in range(1, 6):
+        update_qpu_sample_slot(slot)
+
+
+def cmap_for_field(field: str):
+    """Choose colormap per field (Ez→Reds, Hx→Greens, Hy→Blues)."""
+    f = str(field)
+    if f == 'Ez':
+        return _mpl_cm.Reds
+    if f == 'Hx':
+        return _mpl_cm.Greens
+    return _mpl_cm.Blues
+
+
+def update_qpu_position_options(current_field: str = "All"):
+    """Update QPU position filter options based on current field."""
+    try:
+        field_key = (current_field or "All").strip() or "All"
+        pos_map = qpu_ts_cache.get("positions_by_field") or {}
+        entries = pos_map.get(field_key) or pos_map.get("All") or []
+        labels = []
+        for entry in entries:
+            label = None
+            if isinstance(entry, dict):
+                label = entry.get("label")
+                if not label:
+                    coords = entry.get("coords") or (None, None)
+                    fld = entry.get("field")
+                    label = format_grid_label(coords[0], coords[1], fld)
+            elif isinstance(entry, (list, tuple)) and len(entry) >= 2:
+                lbl_field = entry[2] if len(entry) >= 3 else (field_key if field_key not in ("", "All") else None)
+                label = format_grid_label(entry[0], entry[1], lbl_field)
+            if label:
+                labels.append(label)
+        labels = list(dict.fromkeys(labels))
+        options = ["All positions"] + labels if labels else ["All positions"]
+        state.qpu_plot_position_options = options
+        if state.qpu_plot_position_filter not in options:
+            state.qpu_plot_position_filter = options[0]
+    except Exception:
+        pass
+
+
+def filter_series_keys(series_map, field_filter: str, position_filter: str):
+    """Filter series keys based on field and position filters."""
+    keys = list(series_map.keys())
+    ff = (field_filter or "All").strip()
+    pf = (position_filter or "All positions").strip()
+    if ff not in ("", "All"):
+        keys = [k for k in keys if str(k[0]) == ff]
+    if pf not in ("", "All", "All positions"):
+        label_map = qpu_ts_cache.get("label_to_keys") or {}
+        label_keys = label_map.get(pf)
+        if not label_keys:
+            return []
+        allowed = {(str(fld), int(px), int(py)) for (fld, px, py) in label_keys}
+        keys = [k for k in keys if (str(k[0]), int(k[1]), int(k[2])) in allowed]
+    return keys
+
+
+def refresh_qpu_plot_figures():
+    """Refresh QPU plot figures with current filter settings."""
+    try:
+        field_filter = (state.qpu_plot_filter or "All").strip()
+    except Exception:
+        field_filter = "All"
+    try:
+        position_filter = (state.qpu_plot_position_filter or "All positions").strip()
+    except Exception:
+        position_filter = "All positions"
+
+    fig_all = qpu_ts_cache.get("fig")
+    times = qpu_ts_cache.get("times") or []
+    series_map = qpu_ts_cache.get("series_map") or {}
+    if fig_all is None or not times or not series_map:
+        return
+
+    update_qpu_position_options(field_filter)
+    fig_primary = rebuild_qpu_fig_filtered(field_filter, position_filter)
+    if fig_primary is None:
+        fig_primary = fig_all
+
+    if fig_primary is not None:
+        try:
+            ctrl.qpu_ts_update(fig_primary)
+        except Exception:
+            pass
+        state.qpu_ts_ready = True
+        state.qpu_plot_style = "width: 900px; height: 660px; margin: 0 auto;"
+    else:
+        state.qpu_ts_ready = False
+        state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+
+    if field_filter not in ("", "All") and position_filter in ("", "All", "All positions"):
+        fig_oth = rebuild_qpu_fig_others(field_filter, position_filter)
+        if fig_oth is not None and getattr(fig_oth, "data", None):
+            try:
+                ctrl.qpu_ts_other_update(fig_oth)
+            except Exception:
+                pass
+            state.qpu_ts_other_ready = True
+            state.qpu_other_plot_style = "width: 900px; height: 660px; margin: 0 auto;"
+        else:
+            state.qpu_ts_other_ready = False
+            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+    else:
+        state.qpu_ts_other_ready = False
+        state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+
+
+def build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt: float, impulse_pos, progress_callback=None, print_callback=None):
+    """Build multi-config Plotly time series for QPU results."""
+    times = qutils.create_time_frames(T, snapshot_dt)
+    fig = go.Figure()
+    
+    all_triplets = []
+    cfg_expanded = []
+    
+    for cfg in (configs or []):
+        field_type = (cfg.get("field") or "Ez").strip()
+        pts_str = str(cfg.get("points") or "").strip()
+        fields = ('Ez', 'Hx', 'Hy') if field_type == 'All' else (field_type,)
+        raw_pts = [tuple(map(int, m)) for m in re.findall(r"\((\d+)\s*,\s*(\d+)\)", pts_str)] or [impulse_pos]
+        for f in fields:
+            if f == 'Ez':
+                gw, gh = nx, nx
+            elif f == 'Hx':
+                gw, gh = nx, nx - 1
+            else:
+                gw, gh = nx - 1, nx
+            valid = []
+            for (px, py) in raw_pts:
+                if 0 <= px < gw and 0 <= py < gh:
+                    valid.append((int(px), int(py)))
+            if not valid:
+                continue
+            cfg_expanded.append((f, valid))
+            all_triplets.extend((f, px, py) for (px, py) in valid)
+    
+    max_sum = max(((px + py) for (_, px, py) in all_triplets), default=1)
+    if max_sum <= 0:
+        max_sum = 1
+
+    series_map = {}
+    positions_by_field = defaultdict(dict)
+    key_to_label = {}
+    label_to_keys = defaultdict(set)
+    max_abs = 0.0
+    dashes = ["solid", "dash", "dot", "dashdot"]
+    markers = ["circle", "square", "diamond", "triangle-up", "x"]
+
+    total_configs = len(cfg_expanded)
+    for idx, (field_type, valid_positions) in enumerate(cfg_expanded):
+        def _sub_progress(p):
+            if progress_callback:
+                base = (idx / total_configs) * 100
+                fraction = (1 / total_configs) * 100
+                total_p = base + (p / 100.0) * fraction
+                progress_callback(total_p)
+
+        try:
+            series_map_field = qutils.run_qpu(
+                field_type, valid_positions, None, 
+                float(T), float(snapshot_dt), int(nx), 
+                None, impulse_pos, 
+                progress_callback=_sub_progress, 
+                print_callback=print_callback
+            )
+        except Exception as e:
+            msg = f"QPU error for {field_type} positions {valid_positions}: {e}"
+            if print_callback:
+                print_callback(msg)
+            continue
+        
+        cmap = cmap_for_field(field_type)
+        num_pts = len(valid_positions)
+        
+        for i, (px, py) in enumerate(valid_positions):
+            ys = (series_map_field or {}).get((px, py), [])
+            if not ys or len(ys) != len(times):
+                continue
+            series_map[(field_type, px, py)] = list(ys)
+            try:
+                max_abs = max(max_abs, max((abs(float(v)) for v in ys)))
+            except Exception:
+                pass
+            
+            if num_pts > 1:
+                s_index = i / (num_pts - 1)
+                s_light = 0.3 + 0.6 * s_index
+            else:
+                s_light = 0.6
+            
+            rgba = cmap(s_light)
+            color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
+            
+            if field_type == 'Ez':
+                gw, gh = nx, nx
+            elif field_type == 'Hx':
+                gw, gh = nx, nx - 1
+            else:
+                gw, gh = nx - 1, nx
+            
+            label = normalized_position_label(px, py, gw, gh)
+            key = (str(field_type), int(px), int(py))
+            key_to_label[key] = label
+            label_to_keys[label].add(key)
+            positions_by_field[str(field_type)][(int(px), int(py))] = {
+                "coords": (int(px), int(py)),
+                "label": label,
+                "field": str(field_type),
+            }
+            
+            fig.add_trace(
+                go.Scatter(
+                    x=times,
+                    y=ys,
+                    mode='lines+markers',
+                    name=label,
+                    line=dict(color=color_hex, width=2.5, dash=dashes[i % len(dashes)]),
+                    marker=dict(size=7, symbol=markers[i % len(markers)], color=color_hex),
+                    hovertemplate=f"{field_type} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>{label}</extra>",
+                )
+            )
+    
+    unique_fields = sorted({f for (f, _, _) in series_map.keys()})
+    fig.update_layout(
+        title=f"Time Series ({', '.join(unique_fields) if unique_fields else '—'})",
+        height=660, width=900,
+        margin=dict(l=50, r=30, t=50, b=50),
+        hovermode="x unified",
+        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, title_text=""),
+        paper_bgcolor="#FFFFFF",
+        plot_bgcolor="#FFFFFF",
+    )
+    fig.update_xaxes(title_text="Time (s)", title_font=dict(size=22), tickfont=dict(size=16), showgrid=True, gridcolor="rgba(0,0,0,.06)")
+    fig.update_yaxes(title_text="Field Value", title_font=dict(size=22), tickfont=dict(size=16), showgrid=True, gridcolor="rgba(0,0,0,.06)")
+    if max_abs > 0:
+        pad = 0.12 * max_abs
+        fig.update_yaxes(range=[-max_abs - pad, max_abs + pad])
+
+    # Update cache
+    qpu_ts_cache["times"] = list(times)
+    qpu_ts_cache["series_map"] = series_map
+    qpu_ts_cache["field"] = ",".join(unique_fields) if len(unique_fields) == 1 else ("multi" if unique_fields else "")
+    qpu_ts_cache["fig"] = fig
+    qpu_ts_cache["unique_fields"] = list(unique_fields)
+    
+    try:
+        positions_map_sorted = {}
+        all_entries = {}
+        for field_name, entry_map in positions_by_field.items():
+            entries = [entry_map[key] for key in sorted(entry_map.keys(), key=lambda xy: (xy[0], xy[1]))]
+            positions_map_sorted[field_name] = entries
+            for entry in entries:
+                all_entries.setdefault(entry["label"], entry)
+        positions_map_sorted["All"] = sorted(all_entries.values(), key=lambda entry: (entry["coords"][0], entry["coords"][1]))
+        qpu_ts_cache["positions_by_field"] = positions_map_sorted
+        qpu_ts_cache["key_to_label"] = key_to_label
+        qpu_ts_cache["label_to_keys"] = {lbl: sorted(list(vals)) for lbl, vals in label_to_keys.items()}
+        qpu_ts_cache["nx"] = int(nx)
+    except Exception:
+        qpu_ts_cache["positions_by_field"] = {"All": []}
+        qpu_ts_cache["key_to_label"] = {}
+        qpu_ts_cache["label_to_keys"] = {}
+    
+    try:
+        state.qpu_plot_field_options = ["All"] + list(unique_fields)
+        state.qpu_plot_filter = "All"
+        update_qpu_position_options("All")
+    except Exception:
+        pass
+    
+    return fig
+
+
+def rebuild_qpu_fig_filtered(filter_value: str, position_filter: str = "All positions"):
+    """Rebuild QPU figure with field/position filters applied."""
+    try:
+        fv = (filter_value or "All").strip()
+        pf = (position_filter or "All positions").strip()
+        fig_all = qpu_ts_cache.get("fig")
+        times = qpu_ts_cache.get("times") or []
+        series_map = qpu_ts_cache.get("series_map") or {}
+        if fig_all is None or not times or not series_map:
+            return fig_all
+        
+        use_base = fv in ("", "All") and pf in ("", "All", "All positions")
+        if use_base:
+            return fig_all
+        
+        keys = filter_series_keys(series_map, fv, pf)
+        if not keys:
+            return None
+        
+        fig = go.Figure()
+        dashes = ["solid", "dash", "dot", "dashdot"]
+        markers = ["circle", "square", "diamond", "triangle-up", "x"]
+        max_abs = 0.0
+        label_map = qpu_ts_cache.get("key_to_label") or {}
+        sorted_keys = sorted(keys, key=lambda x: (str(x[0]), x[1], x[2]))
+        num_keys = len(sorted_keys)
+        
+        for i, k in enumerate(sorted_keys):
+            field_name, px, py = k
+            ys = series_map.get(k) or []
+            if not ys or len(ys) != len(times):
+                continue
+            try:
+                max_abs = max(max_abs, max((abs(float(v)) for v in ys)))
+            except Exception:
+                pass
+            
+            cmap = cmap_for_field(field_name)
+            if num_keys > 1:
+                s_index = i / (num_keys - 1)
+                s_light = 0.3 + 0.6 * s_index
+            else:
+                s_light = 0.6
+            
+            rgba = cmap(s_light)
+            color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
+            label = label_map.get((str(field_name), int(px), int(py))) or format_grid_label(px, py, field_name)
+            
+            fig.add_trace(go.Scatter(
+                x=times,
+                y=ys,
+                mode='lines+markers',
+                name=label,
+                line=dict(color=color_hex, width=2.5, dash=dashes[i % len(dashes)]),
+                marker=dict(size=7, symbol=markers[i % len(markers)], color=color_hex),
+                hovertemplate=f"{field_name} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>{label}</extra>",
+            ))
+        
+        title_parts = []
+        if fv not in ("", "All"):
+            title_parts.append(fv)
+        if pf not in ("", "All", "All positions"):
+            title_parts.append(pf)
+        suffix = " - ".join(title_parts) if title_parts else "Filtered"
+        
+        fig.update_layout(
+            title=f"IBM QPU Time Series ({suffix})",
+            height=660, width=900,
+            margin=dict(l=50, r=30, t=50, b=50),
+            hovermode="x unified",
+            legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1)
+        )
+        fig.update_xaxes(title_text="Time (s)", title_font=dict(size=22), tickfont=dict(size=16))
+        fig.update_yaxes(title_text="Field Value", title_font=dict(size=22), tickfont=dict(size=16))
+        if max_abs > 0:
+            pad = 0.12 * max_abs
+            fig.update_yaxes(range=[-max_abs - pad, max_abs + pad])
+        
+        return fig
+    except Exception:
+        return qpu_ts_cache.get("fig")
+
+
+def rebuild_qpu_fig_others(selected_field: str, position_filter: str = "All positions"):
+    """Build Plotly figure for all components except the selected one."""
+    try:
+        times = qpu_ts_cache.get("times") or []
+        series_map = qpu_ts_cache.get("series_map") or {}
+        if not times or not series_map:
+            return None
+        
+        all_fields = sorted({str(k[0]) for k in series_map.keys()})
+        other_fields = [f for f in all_fields if f != selected_field]
+        if not other_fields:
+            return None
+        
+        keys = [k for k in series_map.keys() if str(k[0]) in other_fields]
+        if not keys:
+            return None
+        
+        fig = go.Figure()
+        dashes = ["solid", "dash", "dot", "dashdot"]
+        markers = ["circle", "square", "diamond", "triangle-up", "x"]
+        max_abs = 0.0
+        label_map = qpu_ts_cache.get("key_to_label") or {}
+        sorted_keys = sorted(keys, key=lambda x: (str(x[0]), x[1], x[2]))
+        num_keys = len(sorted_keys)
+        
+        for i, k in enumerate(sorted_keys):
+            field_name, px, py = k
+            ys = series_map.get(k) or []
+            if not ys or len(ys) != len(times):
+                continue
+            try:
+                max_abs = max(max_abs, max((abs(float(v)) for v in ys)))
+            except Exception:
+                pass
+            
+            cmap = cmap_for_field(field_name)
+            s_light = 0.6 if num_keys == 1 else 0.3 + 0.6 * (i / (num_keys - 1))
+            rgba = cmap(s_light)
+            color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
+            label = label_map.get((str(field_name), int(px), int(py))) or format_grid_label(px, py, field_name)
+            
+            fig.add_trace(go.Scatter(
+                x=times,
+                y=ys,
+                mode='lines+markers',
+                name=label,
+                line=dict(color=color_hex, width=2.5, dash=dashes[i % len(dashes)]),
+                marker=dict(size=7, symbol=markers[i % len(markers)], color=color_hex),
+                hovertemplate=f"{field_name} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>{label}</extra>",
+            ))
+        
+        fig.update_layout(
+            title=f"Other Components ({', '.join(other_fields)})",
+            height=660, width=900,
+            margin=dict(l=50, r=30, t=50, b=50),
+            hovermode="x unified",
+            legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1)
+        )
+        if max_abs > 0:
+            pad = 0.12 * max_abs
+            fig.update_yaxes(range=[-max_abs - pad, max_abs + pad])
+        
+        return fig
+    except Exception:
+        return None
+
+
+# Click handlers
+def on_qpu_ts_click(evt):
+    """Handle click on QPU time series plot."""
+    try:
+        if not evt or "points" not in evt or not evt["points"]:
+            return
+        x = float(evt["points"][0].get("x"))
+        times = qpu_ts_cache.get("times") or []
+        fig = qpu_ts_cache.get("fig")
+        if not times or fig is None:
+            return
+        idx = int(np.argmin(np.abs(np.asarray(times) - x)))
+        sel_t = float(times[idx])
+        fig.update_layout(shapes=[dict(
+            type="line", x0=sel_t, x1=sel_t, y0=0, y1=1, 
+            xref="x", yref="paper", 
+            line=dict(color="#5F259F", width=2, dash="dot")
+        )])
+        qpu_ts_cache["fig"] = fig
+        try:
+            ctrl.qpu_ts_update(fig)
+        except Exception:
+            pass
+        state.qpu_ts_selected_time = sel_t
+    except Exception:
+        pass
+
+
+def on_qpu_ts_clear():
+    """Clear QPU time series selection."""
+    try:
+        fig = qpu_ts_cache.get("fig")
+        if fig is None:
+            return
+        fig.update_layout(shapes=[])
+        qpu_ts_cache["fig"] = fig
+        try:
+            ctrl.qpu_ts_update(fig)
+        except Exception:
+            pass
+        state.qpu_ts_selected_time = None
+    except Exception:
+        pass
+
+
+# Register click handlers on controller
+ctrl.on_qpu_ts_click = on_qpu_ts_click
+ctrl.on_qpu_ts_clear = on_qpu_ts_clear
+
+
+# Monitor config management
+def qpu_add_monitor_config():
+    """Add a new QPU monitor configuration."""
+    from .globals import new_monitor_cfg
+    configs = list(state.qpu_monitor_configs or [])
+    configs.append(new_monitor_cfg())
+    state.qpu_monitor_configs = configs
+
+
+def qpu_remove_monitor_config(index):
+    """Remove a QPU monitor configuration by index."""
+    configs = list(state.qpu_monitor_configs or [])
+    if 0 <= index < len(configs):
+        configs.pop(index)
+        state.qpu_monitor_configs = configs
+
+
+def qpu_set_monitor_field(index, value):
+    """Set the field for a monitor config."""
+    configs = list(state.qpu_monitor_configs or [])
+    if 0 <= index < len(configs):
+        configs[index]["field"] = value
+        state.qpu_monitor_configs = configs
+
+
+def qpu_set_monitor_points(index, value):
+    """Set the points for a monitor config."""
+    configs = list(state.qpu_monitor_configs or [])
+    if 0 <= index < len(configs):
+        configs[index]["points"] = value
+        state.qpu_monitor_configs = configs
+
+
+def qpu_set_plot_filter(value):
+    """Set the component filter and refresh chart."""
+    state.qpu_plot_filter = value
+    update_qpu_position_options(value)
+    refresh_qpu_plot_figures()
+
+
+def qpu_set_plot_position_filter(value):
+    """Set the position filter and refresh chart."""
+    state.qpu_plot_position_filter = value
+    refresh_qpu_plot_figures()
+
+
+def qpu_add_monitor_slot():
+    """Add a new QPU monitor slot."""
+    try:
+        cnt = int(state.qpu_monitor_count or 0)
+    except Exception:
+        cnt = 0
+    if cnt < 4:
+        state.qpu_monitor_count = cnt + 1
+
+
+def qpu_remove_monitor_slot(slot_index):
+    """Remove a QPU monitor slot."""
+    try:
+        cnt = int(state.qpu_monitor_count or 0)
+    except Exception:
+        cnt = 0
+    if slot_index <= cnt:
+        # Shift remaining slots up
+        for i in range(slot_index, cnt):
+            src = i + 1
+            setattr(state, f"qpu_field_components_{i}", getattr(state, f"qpu_field_components_{src}", "Ez"))
+            setattr(state, f"qpu_monitor_gridpoints_{i}", getattr(state, f"qpu_monitor_gridpoints_{src}", ""))
+            setattr(state, f"qpu_monitor_samples_{i}", getattr(state, f"qpu_monitor_samples_{src}", ""))
+            setattr(state, f"qpu_monitor_sample_info_{i}", getattr(state, f"qpu_monitor_sample_info_{src}", ""))
+        state.qpu_monitor_count = max(0, cnt - 1)
+
+
+# Register on controller
+ctrl.qpu_remove_monitor_config = qpu_remove_monitor_config
+ctrl.qpu_set_monitor_field = qpu_set_monitor_field
+ctrl.qpu_set_monitor_points = qpu_set_monitor_points
+ctrl.qpu_set_plot_filter = qpu_set_plot_filter
+ctrl.qpu_set_plot_position_filter = qpu_set_plot_position_filter
+ctrl.qpu_add_monitor_slot = qpu_add_monitor_slot
+ctrl.qpu_remove_monitor_slot = qpu_remove_monitor_slot

em/simulation.py

@@ -0,0 +1,830 @@
+"""
+EM Embedded - Simulation Module
+
+Contains simulation logic including run_simulation_only, reset_to_defaults,
+and stop handlers.
+"""
+import numpy as np
+
+from .state import state, ctrl, _apply_workflow_highlights
+from .globals import (
+    plotter, simulation_data, current_mesh, snapshot_times,
+    stop_simulation, qpu_ts_cache, sim_ts_cache, set_stop_simulation, reset_globals
+)
+
+# Import backend functions
+try:
+    from quantum.utils.delta_impulse_generator import (
+        create_impulse_state, create_gaussian_state,
+        create_impulse_state_from_pos, create_gaussian_state_from_pos,
+        run_sim, create_time_frames
+    )
+    import quantum.utils.delta_impulse_generator as qutils
+except ModuleNotFoundError:
+    from utils.delta_impulse_generator import (
+        create_impulse_state, create_gaussian_state,
+        create_impulse_state_from_pos, create_gaussian_state_from_pos,
+        run_sim, create_time_frames
+    )
+    import utils.delta_impulse_generator as qutils
+
+__all__ = [
+    "run_simulation_only",
+    "reset_to_defaults",
+    "stop_simulation_handler",
+    "log_to_console",
+    "log_message",
+    "setup_surface_plot_data",
+    "generate_plot",
+    "redraw_surface_plot",
+    "update_sim_monitor_points",
+    "add_dotted_unit_grid",
+    "add_dotted_unit_grid_scaled",
+    "build_sim_timeseries_plotly",
+    "update_value_display",
+]
+
+
+def update_sim_monitor_points():
+    """Update simulator monitor points based on timeseries_points input."""
+    from .utils import snap_samples_to_grid
+    
+    sample_value = state.timeseries_points
+    if not sample_value or not str(sample_value).strip():
+        state.timeseries_gridpoints = ""
+        state.timeseries_point_info = ""
+        return
+    nx_val = state.nx
+    if nx_val is None:
+        state.timeseries_gridpoints = ""
+        state.timeseries_point_info = "Select a grid size (nx) to compute the nearest monitor positions."
+        return
+    snapped, message = snap_samples_to_grid(sample_value, int(nx_val))
+    state.timeseries_gridpoints = snapped
+    state.timeseries_point_info = message or ""
+
+
+def log_message(message, level="INFO"):
+    """Log a message to the console."""
+    from datetime import datetime
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    log_line = f"[{timestamp}] [{level}] {message}\n"
+    current = state.console_logs or ""
+    state.console_logs = current + log_line
+
+
+def log_to_console(message):
+    """Log a message to the console output."""
+    current = state.console_output or ""
+    state.console_output = current + message + "\n"
+
+
+def setup_surface_plot_data(sim_data, nx):
+    """Setup surface plot data from simulation results - matches em_embedded.py exactly."""
+    from . import globals as g
+    
+    nx = int(nx)
+    mask = np.arange(1, nx * nx + 1) % nx != 0
+    
+    g.data_frames = {'Ez': [], 'Hx': [], 'Hy': []}
+    g.surface_clims = {'Ez': [np.inf, -np.inf], 'Hx': [np.inf, -np.inf], 'Hy': [np.inf, -np.inf]}
+    
+    for u in sim_data:
+        ez = u[:nx*nx].reshape(nx, nx)
+        hx = u[2*nx*nx:3*nx*nx-nx].reshape(nx-1, nx)
+        hy = u[-nx*nx:][mask].reshape(nx, nx-1)
+        
+        g.data_frames['Ez'].append(ez)
+        g.data_frames['Hx'].append(hx)
+        g.data_frames['Hy'].append(hy)
+        
+        if ez.size > 0:
+            g.surface_clims['Ez'][0] = min(g.surface_clims['Ez'][0], ez.min())
+            g.surface_clims['Ez'][1] = max(g.surface_clims['Ez'][1], ez.max())
+        if hx.size > 0:
+            g.surface_clims['Hx'][0] = min(g.surface_clims['Hx'][0], hx.min())
+            g.surface_clims['Hx'][1] = max(g.surface_clims['Hx'][1], hx.max())
+        if hy.size > 0:
+            g.surface_clims['Hy'][0] = min(g.surface_clims['Hy'][0], hy.min())
+            g.surface_clims['Hy'][1] = max(g.surface_clims['Hy'][1], hy.max())
+    
+    # Prevent zero-range clims
+    for key in g.surface_clims:
+        if g.surface_clims[key][0] == g.surface_clims[key][1]:
+            g.surface_clims[key][0] -= 1e-9
+            g.surface_clims[key][1] += 1e-9
+    
+    # Use integer grid coordinates (like em_embedded.py / app.py)
+    x = np.arange(nx)
+    y = np.arange(nx)
+    x_m1 = np.arange(nx - 1)
+    y_m1 = np.arange(nx - 1)
+    
+    g.X_grids['Ez'], g.Y_grids['Ez'] = np.meshgrid(x, y)
+    g.X_grids['Hx'], g.Y_grids['Hx'] = np.meshgrid(x, y_m1)
+    g.X_grids['Hy'], g.Y_grids['Hy'] = np.meshgrid(x_m1, y)
+    
+    # Compute z_scale for visualization
+    finite_vals = [abs(float(v)) for pair in g.surface_clims.values() for v in pair if np.isfinite(v)]
+    max_abs = max(finite_vals) if finite_vals else 1e-9
+    g.z_scale = (nx / 2) / max(max_abs, 1e-9)
+    
+    g.simulation_data = sim_data
+
+
+def generate_plot():
+    """Generate the plot based on output_type selection."""
+    import re
+    from . import globals as g
+    
+    if not state.simulation_has_run:
+        return
+
+    plotter.clear()
+    try:
+        plotter.disable_picking()
+    except Exception:
+        pass
+
+    nx = int(state.nx)
+
+    if state.output_type == "Surface Plot":
+        redraw_surface_plot()
+    else:  # Time Series -> Plotly for Simulator
+        try:
+            points_str = state.timeseries_gridpoints or ""
+            positions = [tuple(map(int, match)) for match in re.findall(r'\((\d+)\s*,\s*(\d+)\)', points_str)]
+            if not positions and (state.timeseries_points or "").strip():
+                raise ValueError("No valid monitor positions found. Enter (x, y) pairs in [0,1] x [0,1].")
+            
+            fig = build_sim_timeseries_plotly(state.timeseries_field, positions, nx, g.snapshot_times, g.simulation_data)
+            if fig is not None:
+                # Cache the figure for export
+                g.sim_ts_cache["fig"] = fig
+                g.sim_ts_cache["field"] = state.timeseries_field
+                try:
+                    ctrl.sim_ts_update(fig)
+                except Exception:
+                    pass
+        except Exception as e:
+            state.error_message = f"Plotting Error: {e}"
+
+    ctrl.view_update()
+
+
+def redraw_surface_plot():
+    """Redraw the surface plot with current field and time - matches em_embedded.py."""
+    import pyvista as pv
+    from . import globals as g
+    
+    plotter.clear()
+    
+    field = state.surface_field
+    if g.data_frames is None or not g.data_frames.get(field):
+        return
+    if g.snapshot_times is None or len(g.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(g.snapshot_times)
+    idx = int(np.argmin(np.abs(times - req_t)))
+    max_idx = len(g.data_frames[field]) - 1
+    idx = max(0, min(idx, max_idx))
+
+    z_data = g.data_frames[field][idx]
+    X = g.X_grids[field]
+    Y = g.Y_grids[field]
+    
+    points = np.c_[X.ravel(), Y.ravel(), z_data.ravel() * g.z_scale]
+    poly = pv.PolyData(points)
+    mesh = poly.delaunay_2d()
+    mesh['scalars'] = z_data.ravel()
+    g.current_mesh = mesh
+    
+    # Add mesh with styling matching em_embedded.py
+    plotter.add_mesh(
+        mesh,
+        scalars='scalars',
+        clim=g.surface_clims[field],
+        cmap="Blues",
+        show_scalar_bar=False,
+        show_edges=True,
+        edge_color='grey',
+        line_width=0.5
+    )
+    plotter.add_scalar_bar(title=f"{field} Amplitude")
+    
+    # Enable point picking
+    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()
+
+
+def run_simulation_only():
+    """Run the simulation based on current state settings."""
+    from . import globals as g
+    from .excitation import nearest_node_index
+    from .qpu import build_qpu_timeseries_plotly_multi
+    
+    # Require selections before running
+    if not state.geometry_selection:
+        state.error_message = "Please select a geometry before running the simulation."
+        log_to_console("Error: Please select a geometry before running.")
+        state.status_visible = True
+        state.status_message = "Error: Please select a geometry before running."
+        state.status_type = "error"
+        state.show_progress = False
+        state.is_running = False
+        state.run_button_text = "RUN!"
+        return
+    
+    if not state.dist_type:
+        state.error_message = "Please select an initial state before running the simulation."
+        log_to_console("Error: Please select an initial state before running.")
+        state.status_visible = True
+        state.status_message = "Error: Please select an initial state before running."
+        state.status_type = "error"
+        state.show_progress = False
+        state.is_running = False
+        state.run_button_text = "RUN!"
+        return
+    
+    # Show status: Starting simulation
+    state.status_visible = True
+    state.status_message = "Initializing simulation..."
+    log_to_console("Initializing simulation...")
+    state.status_type = "info"
+    state.show_progress = True
+    state.simulation_progress = 0
+    
+    last_logged_percent = [0]
+    def _progress_callback(percent):
+        state.simulation_progress = percent
+        if percent - last_logged_percent[0] >= 10:
+            log_to_console(f"Simulation progress: {int(percent)}%")
+            last_logged_percent[0] = percent
+
+    # Reset stop flag and enable Stop button at start
+    set_stop_simulation(False)
+    state.stop_button_disabled = False
+
+    plotter.clear()
+    g.current_mesh = None
+    state.error_message = ""
+    state.is_running = True
+    state.simulation_has_run = False
+    state.run_button_text = "Running"
+    try:
+        ctrl.view_update()
+    except Exception:
+        pass
+    
+    nx, T = int(state.nx), float(state.T)
+    na, R = 1, 4
+    
+    try:
+        state.status_message = "Creating initial state..."
+        state.simulation_progress = 10
+        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.status_message = f"Error: {e}"
+        state.status_type = "error"
+        state.show_progress = False
+        state.is_running = False
+        state.run_button_text = "RUN!"
+        state.stop_button_disabled = True
+        return
+
+    # If QPU selected, build QPU time series chart and return
+    if state.backend_type == "QPU":
+        try:
+            log_to_console("Running QPU...")
+            state.status_message = "Running QPU simulation..."
+            state.simulation_progress = 20
+            state.qpu_ts_ready = False
+            state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            state.qpu_ts_other_ready = False
+            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            
+            # Inputs for QPU
+            snapshot_dt = float(state.dt_user)
+            ix_imp, iy_imp = nearest_node_index(float(state.impulse_x), float(state.impulse_y), nx)
+            impulse_pos = (ix_imp, iy_imp)
+            
+            # Build configs from primitive slots
+            configs = [{
+                "field": (state.qpu_field_components or "Ez"),
+                "points": (state.qpu_monitor_gridpoints or ""),
+            }]
+            try:
+                cnt = int(state.qpu_monitor_count or 0)
+            except Exception:
+                cnt = 0
+            for slot_num in range(2, 2 + cnt):
+                f = getattr(state, f"qpu_field_components_{slot_num}", "Ez") or "Ez"
+                p = getattr(state, f"qpu_monitor_gridpoints_{slot_num}", "") or ""
+                configs.append({"field": f, "points": p})
+            
+            state.status_message = "Building QPU time series..."
+            state.simulation_progress = 60
+            
+            # Build and render Plotly chart
+            fig = build_qpu_timeseries_plotly_multi(
+                configs, nx, T, snapshot_dt, impulse_pos, 
+                progress_callback=_progress_callback, 
+                print_callback=log_to_console
+            )
+            qpu_ts_cache["fig"] = fig
+            
+            try:
+                ctrl.qpu_ts_update(fig)
+            except Exception:
+                pass
+            
+            state.simulation_has_run = True
+            state.run_button_text = "Successful!"
+            state.simulation_progress = 100
+            state.status_message = "QPU simulation completed successfully!"
+            log_to_console("Simulation Completed")
+            state.status_type = "success"
+            state.show_progress = False
+            
+            ready = bool(getattr(fig, "data", None)) and len(fig.data) > 0
+            state.qpu_ts_ready = ready
+            state.qpu_plot_style = (
+                "width: 900px; height: 660px; margin: 0 auto;"
+                if ready else "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            )
+            state.qpu_ts_other_ready = False
+            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            
+            if not ready:
+                state.error_message = "No QPU time series generated. Check Δt, T, nx, and monitor points."
+                state.status_message = "Warning: No QPU time series generated."
+                state.status_type = "warning"
+            log_to_console("QPU complete.")
+            
+        except Exception as e:
+            state.error_message = f"QPU run failed: {e}"
+            state.status_message = f"QPU Error: {e}"
+            state.status_type = "error"
+            state.show_progress = False
+            state.run_button_text = "RUN!"
+            state.qpu_ts_ready = False
+            log_to_console(f"QPU error: {e}")
+        finally:
+            state.is_running = False
+            state.stop_button_disabled = True
+            try:
+                ctrl.view_update()
+            except Exception:
+                pass
+        return
+
+    # Simulator path
+    log_to_console("Running simulation...")
+    state.status_message = "Running simulation... This may take a while."
+    state.simulation_progress = 30
+    
+    snapshot_dt = float(state.dt_user)
+    
+    def _stop_check():
+        return g.stop_simulation
+    
+    state.simulation_progress = 50
+    sim_data, times = run_sim(
+        nx, na, R, initial_state, T, 
+        snapshot_dt=snapshot_dt, 
+        stop_check=_stop_check, 
+        progress_callback=_progress_callback, 
+        print_callback=log_to_console
+    )
+    g.simulation_data = sim_data
+    g.snapshot_times = times
+    log_to_console("Simulation complete.")
+    
+    state.simulation_progress = 80
+    state.status_message = "Processing simulation results..."
+    
+    if sim_data.size > 0:
+        setup_surface_plot_data(sim_data, nx)
+        state.simulation_has_run = True
+        state.run_button_text = "Successful!"
+        state.simulation_progress = 100
+        state.status_message = "Simulation completed successfully!"
+        state.status_type = "success"
+        state.show_progress = False
+        generate_plot()
+    else:
+        state.error_message = "Simulation produced no data. Check parameters (e.g., T > 0)."
+        state.status_message = "Error: Simulation produced no data."
+        state.status_type = "error"
+        state.show_progress = False
+        state.run_button_text = "RUN!"
+
+    state.is_running = False
+    state.stop_button_disabled = True
+
+
+def reset_to_defaults():
+    """Reset all parameters to their default values."""
+    from .excitation import update_initial_state_preview, update_sim_monitor_points
+    from . import globals as g
+    
+    # Stop any running simulation
+    set_stop_simulation(True)
+    
+    # Reset global variables
+    reset_globals()
+    
+    # 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": "(0.5, 0.5)",
+        "timeseries_gridpoints": "",
+        "timeseries_point_info": "",
+        "error_message": "",
+        "excitation_info_message": "",
+        "excitation_config_open": False,
+        "is_running": False,
+        "simulation_has_run": False,
+        "geometry_selection": None,
+        "coeff_permittivity": 1.0,
+        "coeff_permeability": 1.0,
+        "run_button_text": "RUN!",
+        "backend_type": None,
+        "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": "",
+        "qpu_field_components": "Ez",
+        "qpu_monitor_gridpoints": "",
+        "qpu_monitor_samples": "(0.5, 0.5)",
+        "qpu_monitor_sample_info": "",
+        "qpu_monitor_count": 0,
+        "qpu_plot_filter": "All",
+        "qpu_plot_field_options": ["All"],
+        "qpu_plot_position_filter": "All positions",
+        "qpu_plot_position_options": ["All positions"],
+        "qpu_ts_ready": False,
+        "qpu_plot_style": "display: none; width: 900px; height: 660px; margin: 0 auto;",
+        "qpu_ts_other_ready": False,
+        "qpu_other_plot_style": "display: none; width: 900px; height: 660px; margin: 0 auto;",
+        "pyvista_view_style": "aspect-ratio: 1 / 1; width: 100%;",
+    })
+
+    # Reset QPU cache
+    qpu_ts_cache.update({
+        "times": None,
+        "series_map": None,
+        "field": None,
+        "fig": None,
+        "positions_by_field": {"All": []},
+        "key_to_label": {},
+        "label_to_keys": {},
+        "nx": None,
+    })
+    
+    # Ensure stop flag is cleared for next run
+    set_stop_simulation(False)
+    
+    # Update monitors
+    update_sim_monitor_points()
+    _apply_workflow_highlights(0)
+
+    # Update the preview with default values
+    update_initial_state_preview()
+    print("Reset to default settings")
+
+
+def stop_simulation_handler():
+    """Stop the currently running simulation."""
+    set_stop_simulation(True)
+    state.status_message = "Stopping simulation..."
+    state.status_type = "warning"
+    log_to_console("Stopping simulation...")
+
+
+# ---------------------------------------------------------------------------
+# Grid overlay helpers for PyVista plots
+# ---------------------------------------------------------------------------
+
+def add_dotted_unit_grid(pl, ticks=(0.0, 0.25, 0.5, 0.75, 1.0), segments=48, gap_ratio=0.4, color="#AE8BD8", line_width=0.2):
+    """Add a dotted unit grid (0..1) overlay in light Synopsys purple."""
+    import pyvista as pv
+    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)])
+                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)
+            pl.add_mesh(poly, color=color, line_width=line_width, name="dotted_unit_grid", pickable=False)
+    except Exception:
+        pass
+
+
+def add_dotted_unit_grid_scaled(pl, 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."""
+    import pyvista as pv
+    from . import globals as g
+    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(g.current_mesh.points[:, 2].min()) - 1e-6 if g.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:
+            pl.remove_actor(name)
+        except Exception:
+            pass
+        if pts and lines:
+            poly = pv.PolyData(np.array(pts))
+            poly.lines = np.array(lines)
+            pl.add_mesh(poly, color=color, line_width=line_width, name=name, pickable=False)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Simulator timeseries plot builder
+# ---------------------------------------------------------------------------
+
+def build_sim_timeseries_plotly(field_type: str, positions, nx: int, times, sim_data):
+    """Build a Plotly figure for simulator timeseries data."""
+    import plotly.graph_objects as go
+    from matplotlib import cm as _cm
+    from .utils import normalized_position_label
+    
+    try:
+        def _rgba_to_hex(rgba):
+            r, g, b, a = rgba
+            return "#%02x%02x%02x" % (int(r*255), int(g*255), int(b*255))
+
+        n_frames = int(sim_data.shape[0]) if sim_data is not None else 0
+        time_axis = np.asarray(times) if times is not None else np.arange(n_frames)
+
+        def _dims(f):
+            if f == 'Ez':
+                return nx, nx
+            if f == 'Hx':
+                return nx, nx - 1
+            return nx - 1, nx  # Hy
+
+        def _valid_positions(f, pts):
+            gw, gh = _dims(f)
+            out = []
+            for (px, py) in pts:
+                if 0 <= px < gw and 0 <= py < gh:
+                    out.append((int(px), int(py)))
+            return out
+
+        fig = go.Figure()
+
+        if not positions or sim_data is None or n_frames == 0:
+            fig.update_layout(
+                title="Time Series (Simulator)",
+                height=660, width=900,
+                margin=dict(l=50, r=30, t=50, b=50),
+                xaxis=dict(title="Time (s)", title_font=dict(size=22), tickfont=dict(size=16), showline=True, linewidth=1, linecolor="rgba(0,0,0,.3)", gridcolor="rgba(0,0,0,.06)", showspikes=True, spikemode='across', spikesnap='cursor'),
+                yaxis=dict(title="Field Amplitude", title_font=dict(size=22), tickfont=dict(size=16), showline=True, linewidth=1, linecolor="rgba(0,0,0,.3)", gridcolor="rgba(0,0,0,.06)", zeroline=True, zerolinecolor="rgba(0,0,0,.25)"),
+                hovermode="x unified",
+                legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1),
+            )
+            return fig
+
+        max_sum = max((px + py) for (px, py) in positions) if positions else 1
+        if max_sum <= 0:
+            max_sum = 1
+
+        cmap_map = {
+            'Ez': _cm.Reds,
+            'Hx': _cm.Greens,
+            'Hy': _cm.Blues,
+        }
+
+        def _add_field_traces(f_name: str, pts):
+            nonlocal fig
+            gw, gh = _dims(f_name)
+            valid_pts = _valid_positions(f_name, pts)
+            if not valid_pts:
+                return 0.0, 0
+            max_abs_local = 0.0
+            num_keys = len(valid_pts)
+            for i, (px, py) in enumerate(valid_pts):
+                if f_name == 'Ez':
+                    values = sim_data[:, py * gw + px]
+                elif f_name == 'Hx':
+                    block = sim_data[:, 2*nx*nx : 3*nx*nx-nx].reshape(n_frames, gh, gw)
+                    values = block[:, py, px]
+                else:  # Hy
+                    mask = np.arange(1, nx * nx + 1) % nx != 0
+                    raw_block = sim_data[:, -nx*nx:]
+                    values = np.array([raw_block[t, mask].reshape(nx, nx - 1)[py, px] for t in range(n_frames)])
+                try:
+                    max_abs_local = max(max_abs_local, float(np.max(np.abs(values))))
+                except Exception:
+                    pass
+                
+                if num_keys > 1:
+                    s_index = i / (num_keys - 1)
+                    s_light = 0.3 + 0.6 * s_index
+                else:
+                    s_light = 0.6
+                
+                rgba = cmap_map.get(f_name, _cm.Blues)(s_light)
+                color_hex = _rgba_to_hex(rgba)
+                dash_styles = ["solid", "dash", "dot", "dashdot"]
+                marker_symbols = ["circle", "square", "diamond", "triangle-up", "x"]
+                label = normalized_position_label(px, py, gw, gh)
+                fig.add_trace(go.Scatter(
+                    x=time_axis,
+                    y=values,
+                    mode='lines+markers',
+                    name=label,
+                    line=dict(color=color_hex, width=2.5, dash=dash_styles[i % len(dash_styles)]),
+                    marker=dict(size=7, symbol=marker_symbols[i % len(marker_symbols)], color=color_hex, line=dict(width=0)),
+                    hovertemplate=f"{f_name} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>{label}</extra>",
+                ))
+            return max_abs_local, len(valid_pts)
+
+        max_abs = 0.0
+        total_traces = 0
+        if str(field_type) == 'All':
+            for f in ('Ez', 'Hx', 'Hy'):
+                m, n_tr = _add_field_traces(f, positions)
+                max_abs = max(max_abs, m)
+                total_traces += n_tr
+        else:
+            m, n_tr = _add_field_traces(str(field_type), positions)
+            max_abs = max(max_abs, m)
+            total_traces += n_tr
+
+        title_suffix = str(field_type) if str(field_type) != 'All' else 'Ez, Hx, Hy'
+        fig.update_layout(
+            title=f"Time Series (Simulator: {title_suffix})",
+            height=660, width=900,
+            margin=dict(l=50, r=30, t=50, b=50),
+            hovermode="x unified",
+            legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, title_text=""),
+            paper_bgcolor="#FFFFFF",
+            plot_bgcolor="#FFFFFF",
+        )
+        fig.update_xaxes(
+            title_text="Time (s)", title_font=dict(size=22), tickfont=dict(size=16),
+            showgrid=True, gridcolor="rgba(95,37,159,0.08)", zeroline=False,
+            showline=True, linewidth=1, linecolor="rgba(0,0,0,.2)",
+            showspikes=True, spikemode='across', spikesnap='cursor'
+        )
+        fig.update_yaxes(
+            title_text="Field Amplitude", title_font=dict(size=22), tickfont=dict(size=16),
+            showgrid=True, gridcolor="rgba(95,37,159,0.08)", zeroline=True, zerolinecolor="rgba(0,0,0,.25)",
+            showline=True, linewidth=1, linecolor="rgba(0,0,0,.2)"
+        )
+        if max_abs > 0:
+            pad = 0.12 * max_abs
+            fig.update_yaxes(range=[-max_abs - pad, max_abs + pad])
+        return fig
+    except Exception:
+        import plotly.graph_objects as go
+        return go.Figure(layout=dict(height=660, width=900))
+
+
+# ---------------------------------------------------------------------------
+# Value display for picked points on the mesh
+# ---------------------------------------------------------------------------
+
+def update_value_display(point):
+    """Update value display when a point is picked on the mesh."""
+    from . import globals as g
+    
+    if g.current_mesh is None:
+        return
+    try:
+        plotter.remove_actor("value_text")
+    except Exception:
+        pass
+
+    closest_id = g.current_mesh.find_closest_point(point)
+    if closest_id == -1:
+        return
+
+    value = g.current_mesh['scalars'][closest_id] if 'scalars' in g.current_mesh.array_names else 0.0
+    px, py, pz = g.current_mesh.points[closest_id]
+    px = float(px)
+    py = float(py)
+
+    xmin, xmax, ymin, ymax, _, _ = g.current_mesh.bounds
+    is_unit_square = (xmax <= 1.00001 and ymax <= 1.00001)
+
+    if not state.simulation_has_run and is_unit_square:
+        text = f"Position: ({px:.3f}, {py:.3f})\nValue: {value:.3e}"
+    else:
+        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()

em/state.py

@@ -0,0 +1,341 @@
+"""
+EM Embedded - State Management Module
+
+Contains deferred state/controller proxy classes and state initialization.
+These allow using state.update(), @state.change(), and ctrl.xxx at module
+load time, then applying them when set_server() is called.
+"""
+
+__all__ = [
+    "state", "ctrl", "set_server", "init_state",
+    "enable_point_picking_on_plotter",
+    "_apply_workflow_highlights", "_determine_workflow_step",
+]
+
+
+class _DeferredStateProxy:
+    """
+    A proxy that collects state defaults and change decorators at module load time,
+    then applies them to the real server.state when bind() is called.
+    """
+
+    def __init__(self):
+        self._state = None
+        self._defaults = {}
+        self._pending_changes = []  # list of (keys, func)
+
+    def bind(self, real_state):
+        """Bind to the real state object and apply all pending operations."""
+        self._state = real_state
+        # Apply all collected defaults
+        if self._defaults:
+            real_state.update(self._defaults)
+            self._defaults.clear()
+        # Apply all pending @state.change decorators
+        for keys, func in self._pending_changes:
+            real_state.change(*keys)(func)
+        self._pending_changes.clear()
+
+    @property
+    def bound(self):
+        return self._state is not None
+
+    def update(self, d):
+        """Collect defaults; apply immediately if bound."""
+        if self._state is not None:
+            self._state.update(d)
+        else:
+            self._defaults.update(d)
+
+    def change(self, *keys):
+        """
+        Decorator factory that mimics @state.change("key1", "key2").
+        If already bound, apply immediately. Otherwise, queue for later.
+        """
+        def decorator(func):
+            if self._state is not None:
+                # Already bound - register directly
+                self._state.change(*keys)(func)
+            else:
+                # Queue for later
+                self._pending_changes.append((keys, func))
+            return func
+        return decorator
+
+    def __getattr__(self, name):
+        if name.startswith("_"):
+            raise AttributeError(name)
+        if self._state is None:
+            raise AttributeError(f"State not bound yet; cannot access '{name}'")
+        return getattr(self._state, name)
+
+    def __setattr__(self, name, value):
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        elif self._state is not None:
+            setattr(self._state, name, value)
+        else:
+            # Store as a default
+            self._defaults[name] = value
+
+
+class _DeferredControllerProxy:
+    """
+    A proxy that collects controller attribute assignments at module load time,
+    then applies them when bind() is called.
+    """
+
+    def __init__(self):
+        self._ctrl = None
+        self._pending = {}
+
+    def bind(self, real_ctrl):
+        """Bind to the real controller and apply pending attributes."""
+        self._ctrl = real_ctrl
+        for name, value in self._pending.items():
+            setattr(real_ctrl, name, value)
+        self._pending.clear()
+
+    @property
+    def bound(self):
+        return self._ctrl is not None
+
+    def __getattr__(self, name):
+        if name.startswith("_"):
+            raise AttributeError(name)
+        if self._ctrl is None:
+            raise AttributeError(f"Controller not bound yet; cannot access '{name}'")
+        return getattr(self._ctrl, name)
+
+    def __setattr__(self, name, value):
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        elif self._ctrl is not None:
+            setattr(self._ctrl, name, value)
+        else:
+            self._pending[name] = value
+
+
+# Module-level proxies (will be bound when set_server is called)
+_server = None
+state = _DeferredStateProxy()
+ctrl = _DeferredControllerProxy()
+
+
+def _noop(*_, **__):
+    """No-op placeholder for controller methods."""
+    pass
+
+
+# Pre-register controller methods as no-ops
+ctrl.qpu_ts_update = _noop
+ctrl.qpu_ts_other_update = _noop
+ctrl.view_update = _noop
+ctrl.sim_ts_update = _noop
+ctrl.geometry_preview_update = _noop
+ctrl.excitation_preview_update = _noop
+ctrl.qubit_plot_update = _noop
+
+
+def set_server(server):
+    """Bind the embedded EM module to the shared Trame server."""
+    global _server
+    _server = server
+    state.bind(server.state)
+    ctrl.bind(server.controller)
+
+
+def get_server():
+    """Get the bound server instance."""
+    return _server
+
+
+# --- Workflow Highlighting ---
+_WORKFLOW_CARD_KEYS = [
+    "overview_card_style",
+    "geometry_card_style",
+    "excitation_card_style",
+    "meshing_card_style",
+    "backend_card_style",
+    "output_card_style",
+]
+
+
+def _workflow_highlight_style(active: bool) -> str:
+    base = "font-size: 0.8rem; border: 1px solid transparent; transition: box-shadow 0.2s ease;"
+    return f"{base} box-shadow: 0 0 0 2px #6200ea;" if active else base
+
+
+def _determine_workflow_step() -> int:
+    """Determine the current workflow step based on state."""
+    if not state.bound:
+        return 0
+    if state.problem_selection is None:
+        return 0
+    if state.geometry_selection is None:
+        return 1
+    if state.dist_type is None:
+        return 2
+    if state.nx is None:
+        return 3
+    if state.backend_type is None:
+        return 4
+    return 5
+
+
+def _apply_workflow_highlights(step_index: int):
+    """Apply highlight styles to workflow cards."""
+    for i, key in enumerate(_WORKFLOW_CARD_KEYS):
+        setattr(state, key, _workflow_highlight_style(i == step_index))
+
+
+# --- State Defaults ---
+def _init_state_defaults():
+    """Initialize all EM state defaults."""
+    state.update({
+        "problem_selection": None,
+        "geometry_options": ["None", "Square Metallic Body", "Square Domain", "Geometry 2", "Add"],
+        "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": 1.0, 
+        "time_val": 0.0,
+        "L": 1.0,
+        "output_type": "Surface Plot",
+        "surface_field": "Ez",
+        "timeseries_field": "Ez",
+        "timeseries_points": "(0.5, 0.5)",
+        "timeseries_gridpoints": "",
+        "timeseries_point_info": "",
+        "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,
+        "coeff_permeability": 1.0,
+        "run_button_text": "RUN!",
+        "backend_type": None,
+        "selected_simulator": "IBM Qiskit simulator",
+        "selected_qpu": "IBM QPU",
+        "stop_button_disabled": True,
+        "export_format": "vtk",
+        "nx_slider_index": None,
+        "show_export_status": False,
+        "export_status_message": "",
+        "logo_src": None,
+        # Geometry-hole controls
+        "hole_size_edge": 0.2,
+        "hole_center_x": 0.5,
+        "hole_center_y": 0.5,
+        "hole_center_pair": "(0.5, 0.5)",
+        "hole_error_message": "",
+        "excitation_error_message": "",
+        "excitation_info_message": "",
+        "excitation_config_open": False,
+        "dt_user": 0.1,
+        "temporal_warning": "",
+        # QPU monitor controls
+        "qpu_field_components": "Ez",
+        "qpu_monitor_gridpoints": "",
+        "qpu_monitor_samples": "(0.5, 0.5)",
+        "qpu_monitor_sample_info": "",
+        "console_output": "Console initialized.\n",
+        "pyvista_view_style": "aspect-ratio: 1 / 1; width: 100%;",
+        # QPU Plotly controls
+        "qpu_ts_fig": None,
+        "qpu_ts_selected_time": None,
+        "qpu_ts_ready": False,
+        "qpu_plot_style": "display: none; width: 900px; height: 660px; margin: 0 auto;",
+        "qpu_ts_other_ready": False,
+        "qpu_other_plot_style": "display: none; width: 900px; height: 660px; margin: 0 auto;",
+        "qpu_monitor_configs": [],
+        "qpu_plot_filter": "All",
+        "qpu_plot_field_options": ["All"],
+        "qpu_plot_position_filter": "All positions",
+        "qpu_plot_position_options": ["All positions"],
+        # Additional QPU monitor slots
+        "qpu_monitor_count": 0,
+        "qpu_field_components_2": "Ez",
+        "qpu_monitor_gridpoints_2": "",
+        "qpu_monitor_samples_2": "",
+        "qpu_monitor_sample_info_2": "",
+        "qpu_field_components_3": "Ez",
+        "qpu_monitor_gridpoints_3": "",
+        "qpu_monitor_samples_3": "",
+        "qpu_monitor_sample_info_3": "",
+        "qpu_field_components_4": "Ez",
+        "qpu_monitor_gridpoints_4": "",
+        "qpu_monitor_samples_4": "",
+        "qpu_monitor_sample_info_4": "",
+        "qpu_field_components_5": "Ez",
+        "qpu_monitor_gridpoints_5": "",
+        "qpu_monitor_samples_5": "",
+        "qpu_monitor_sample_info_5": "",
+        # Status
+        "status_visible": False,
+        "status_message": "Ready",
+        "status_type": "info",
+        "simulation_progress": 0,
+        "show_progress": False,
+        "console_logs": "Console initialized...\n",
+    })
+
+    # Ensure hole snap state exists
+    state.hole_snap = True
+
+
+def init_state(force: bool = False):
+    """Initialize EM state. Called after set_server()."""
+    if not state.bound:
+        return
+    
+    # Apply workflow highlights
+    _apply_workflow_highlights(0)
+    
+    # Load logo
+    from .utils import load_logo_data_uri
+    state.logo_src = load_logo_data_uri()
+    
+    # NOTE: Point picking is enabled later, after the UI is built,
+    # by calling enable_point_picking_on_plotter() or in redraw_surface_plot()
+    
+    if force:
+        from .simulation import reset_to_defaults
+        reset_to_defaults()
+    
+    # Initialize preview
+    try:
+        from .excitation import update_initial_state_preview
+        update_initial_state_preview()
+    except Exception:
+        pass
+
+
+def enable_point_picking_on_plotter():
+    """Enable point picking on the plotter. Call AFTER build_ui()."""
+    from .globals import plotter
+    from .simulation import update_value_display
+    try:
+        plotter.disable_picking()
+    except Exception:
+        pass
+    try:
+        plotter.enable_point_picking(callback=update_value_display, show_message=False)
+    except Exception:
+        pass
+
+
+# Initialize state defaults at module load time
+_init_state_defaults()

em/ui.py

@@ -0,0 +1,738 @@
+"""UI components and build_ui function for the EM module."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import plotly.graph_objects as go
+from trame.widgets import html as trame_html, vuetify3, plotly as plotly_widgets
+from pyvista.trame.ui import plotter_ui
+
+from .state import state, ctrl, get_server
+from .globals import plotter
+from .geometry import build_geometry_placeholder as _build_geometry_placeholder
+from .excitation import build_excitation_placeholder as _build_excitation_placeholder
+from .simulation import run_simulation_only, reset_to_defaults, stop_simulation_handler
+from .exports import (
+    export_vtk, export_vtk_all_frames, export_mp4,
+    export_sim_timeseries_csv, export_sim_timeseries_png, export_sim_timeseries_html,
+    export_qpu_timeseries_csv, export_qpu_timeseries_png, export_qpu_timeseries_html,
+)
+from .handlers import build_qubit_plot
+
+if TYPE_CHECKING:
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Placeholder builders for preview areas
+# ---------------------------------------------------------------------------
+
+def _build_empty_figure(message: str = "") -> go.Figure:
+    """Build an empty placeholder figure with optional message."""
+    fig = go.Figure()
+    if message:
+        fig.add_annotation(
+            text=message,
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=16, color="#888")
+        )
+    fig.update_layout(
+        margin=dict(l=20, r=20, t=40, b=20),
+        paper_bgcolor="#ffffff",
+        plot_bgcolor="#ffffff",
+        height=400,
+    )
+    fig.update_xaxes(visible=False)
+    fig.update_yaxes(visible=False)
+    return fig
+
+
+# ---------------------------------------------------------------------------
+# Main UI Builder
+# ---------------------------------------------------------------------------
+
+def build_ui():
+    """Render the EM UI inside the host layout."""
+    _server = get_server()
+    if _server is None or not state.bound or not ctrl.bound:
+        raise RuntimeError('Call set_server(server) before build_ui().')
+    
+    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+        # Upload Dialog
+        with vuetify3.VDialog(v_model=("show_upload_dialog", False), max_width="500px"):
+            with vuetify3.VCard():
+                vuetify3.VCardTitle("Upload Geometry")
+                with vuetify3.VCardText(classes="py-1 px-2"):
+                    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")
+
+        # Snackbars for status messages
+        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"):
+            # Left Column - Configuration
+            with vuetify3.VCol(cols=5, classes="pa-1 d-flex flex-column"):
+                _build_overview_card()
+                _build_geometry_card()
+                _build_excitation_card()
+                _build_material_card()
+                _build_time_card()
+                _build_meshing_card()
+                _build_backends_card()
+                _build_output_preferences_card()
+                _build_run_buttons()
+                vuetify3.VSpacer()
+                _build_reset_button()
+
+            # Right Column - Visualization
+            with vuetify3.VCol(cols=7, classes="pa-1 d-flex flex-column"):
+                _build_output_config_card()
+                _build_main_plot_area()
+                _build_qpu_plot_area()
+                _build_no_geometry_placeholder()
+                _build_status_console()
+
+        # Floating status window
+        _build_status_window()
+
+
+def _build_overview_card():
+    """Build the Overview/Introduction card."""
+    with vuetify3.VCard(classes="mb-1", style=("overview_card_style", "font-size: 0.8rem;")):
+        with vuetify3.VCardTitle("Overview", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            vuetify3.VSelect(
+                label="Select a problem",
+                v_model=("problem_selection", None),
+                items=(
+                    "problem_options",
+                    [
+                        "Propagation in a given medium (no bodies)",
+                        "Scattering from a perfectly conducting body",
+                    ],
+                ),
+                placeholder="Select a problem",
+                density="compact",
+                color="primary",
+            )
+            vuetify3.VDivider(classes="my-0")
+            vuetify3.VCardSubtitle("Governing Equations", classes="text-caption font-weight-bold mt-0", style="font-size: 0.7rem;")
+            vuetify3.VDivider(classes="mb-0")
+            vuetify3.VListItemTitle("Maxwell's time-domain, 2D, TEz polarized.", classes="text-caption", style="font-size: 0.7rem;")
+            vuetify3.VCardSubtitle("Inputs", classes="text-caption font-weight-bold mt-0", style="font-size: 0.7rem;")
+            vuetify3.VDivider(classes="mb-0")
+            vuetify3.VListItemTitle("Geometry, excitation, medium, output visualization preferences.", classes="text-caption", style="font-size: 0.7rem;")
+            vuetify3.VCardSubtitle("Outputs", classes="text-caption font-weight-bold mt-0", style="font-size: 0.7rem;")
+            vuetify3.VDivider(classes="mb-0")
+            vuetify3.VListItemTitle("Surface plots of field components OR time evolution of field components at specified points.", classes="text-caption", style="font-size: 0.7rem;")
+
+
+def _build_geometry_card():
+    """Build the Geometry configuration card."""
+    with vuetify3.VCard(classes="mb-1", style=("geometry_card_style", "font-size: 0.8rem;")):
+        with vuetify3.VCardTitle("Geometry", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            vuetify3.VSelect(
+                label="Select",
+                v_model=("geometry_selection", None),
+                items=("geometry_options",),
+                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-1",
+                )
+
+
+def _build_excitation_card():
+    """Build the Excitation/Initial State configuration card."""
+    with vuetify3.VCard(classes="mb-1", style=("excitation_card_style", "font-size: 0.8rem;")):
+        with vuetify3.VCardTitle("Excitation: Initial State", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            with vuetify3.VRow(classes="d-flex align-center", dense=True, no_gutters=True):
+                with vuetify3.VCol(classes="flex-grow-1"):
+                    vuetify3.VSelect(
+                        label="Select",
+                        v_model=("dist_type", None),
+                        items=("dist_type_options", ["None", "Delta", "Gaussian"]),
+                        placeholder="Select",
+                        density="compact",
+                        color="primary",
+                    )
+                with vuetify3.VCol(cols="auto", classes="ml-1"):
+                    with vuetify3.VTooltip("Show or hide configuration for the selected excitation", location="bottom", color="primary"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            with vuetify3.VBtn(
+                                icon=True,
+                                density="compact",
+                                variant="text",
+                                click="excitation_config_open = !excitation_config_open",
+                                disabled=("!dist_type", False),
+                                v_bind="props",
+                            ):
+                                vuetify3.VIcon("mdi-cog", color=("excitation_config_open ? 'primary' : 'grey'",))
+                        trame_html.Span("Toggle parameter inputs for the chosen excitation")
+            # Delta config
+            with vuetify3.VExpandTransition():
+                with vuetify3.VSheet(
+                    v_if="excitation_config_open && dist_type === 'Delta'",
+                    classes="pa-2 mt-1 rounded-lg",
+                    style="background-color: rgba(95,37,159,0.03); border: 1px solid rgba(95,37,159,0.15);",
+                ):
+                    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",
+                            )
+            # Gaussian config
+            with vuetify3.VExpandTransition():
+                with vuetify3.VSheet(
+                    v_if="excitation_config_open && dist_type === 'Gaussian'",
+                    classes="pa-2 mt-1 rounded-lg",
+                    style="background-color: rgba(95,37,159,0.03); border: 1px solid rgba(95,37,159,0.15);",
+                ):
+                    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",
+                                    )
+                    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-1")
+            vuetify3.VAlert(
+                v_if="excitation_info_message",
+                type="info",
+                variant="tonal",
+                density="compact",
+                children=["{{ excitation_info_message }}"],
+                classes="mt-1",
+                style="white-space: pre-line;",
+            )
+
+
+def _build_material_card():
+    """Build the Material Properties card."""
+    with vuetify3.VCard(classes="mb-1", style="font-size: 0.8rem;"):
+        with vuetify3.VCardTitle("Material Properties (Medium)", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            with vuetify3.VRow(dense=True):
+                with vuetify3.VCol(cols="6"):
+                    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="Permittivity (εr)", type="number", step="0.1", density="compact", color="primary")
+                with vuetify3.VCol(cols="6"):
+                    with vuetify3.VTooltip("Relative permeability. μ_r = μ / μ₀. Default 1.0 (non-magnetic).", location="bottom", color="primary"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permeability", 1.0), label="Permeability (μr)", type="number", step="0.1", density="compact", color="primary")
+
+
+def _build_time_card():
+    """Build the Time configuration card."""
+    with vuetify3.VCard(classes="mb-1", style="font-size: 0.8rem;"):
+        with vuetify3.VCardTitle("Time", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            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",
+                    )
+
+
+def _build_meshing_card():
+    """Build the Meshing card with qubit plot hover."""
+    with vuetify3.VCard(classes="mb-1", style=("meshing_card_style", "font-size: 0.8rem;")):
+        with vuetify3.VCardTitle("Meshing", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, 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=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 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;",
+                    )
+                    ctrl.qubit_plot_update = qubit_fig_widget.update
+
+
+def _build_backends_card():
+    """Build the Backends selection card."""
+    with vuetify3.VCard(classes="mb-1", style=("backend_card_style", "font-size: 0.8rem;")):
+        with vuetify3.VCardTitle("Backends", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            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'")
+                    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'")
+
+
+def _build_output_preferences_card():
+    """Build the Output Preferences card (appears after backend selection)."""
+    with vuetify3.VCard(v_if="backend_type", classes="mb-0", style=("output_card_style", "font-size: 0.8rem;")):
+        with vuetify3.VCardTitle("Output Preferences", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2"):
+            vuetify3.VCardSubtitle("Select Δt intervals for plotting output snapshots", classes="text-caption font-weight-bold mt-1", style="font-size: 0.75rem;")
+            with vuetify3.VTooltip("Snapshot interval (Δt). Solver runs at fixed 0.1 s; frames are saved every Δt.", 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-1")
+            vuetify3.VAlert(v_if="temporal_warning", type="warning", variant="tonal", density="compact", children=["{{ temporal_warning }}"], classes="mt-1")
+
+            # QPU monitor options
+            with vuetify3.VContainer(v_if="backend_type === 'QPU'", classes="pa-0 mt-2"):
+                with vuetify3.VRow(dense=True, classes="mb-1 align-center"):
+                    with vuetify3.VCol(cols=4, sm=3, md=3):
+                        vuetify3.VSelect(
+                            label="Field",
+                            v_model=("qpu_field_components", "Ez"),
+                            items=("qpu_field_options", ["All", "Ez", "Hx", "Hy"]),
+                            density="compact",
+                            color="primary",
+                            hide_details=True,
+                            style="max-width: 160px;",
+                        )
+                    with vuetify3.VCol(cols=8, sm=9, md=9):
+                        vuetify3.VTextField(
+                            label="Sample position(s) (x, y) in [0,1]",
+                            v_model=("qpu_monitor_samples", "(0.5, 0.5)"),
+                            density="compact",
+                            color="primary",
+                            hide_details=True,
+                            style="max-width: 320px;",
+                        )
+                vuetify3.VAlert(
+                    v_if="qpu_monitor_sample_info",
+                    type="info",
+                    variant="tonal",
+                    density="compact",
+                    children=["{{ qpu_monitor_sample_info }}"],
+                    classes="mb-1",
+                    style="white-space: pre-line;",
+                )
+
+
+def _build_run_buttons():
+    """Build the Run 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.", location="bottom", color="primary"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VBtn(
+                        v_bind="props",
+                        text=("run_button_text", "RUN!"),
+                        click=run_simulation_only,
+                        color="primary",
+                        block=True,
+                        disabled=("is_running || run_button_text === 'Successful!' || !geometry_selection || !dist_type || !!temporal_warning || nx === null || !backend_type", 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),
+                    )
+
+
+def _build_reset_button():
+    """Build the Reset button."""
+    with trame_html.Div(style="flex: 0 0 auto;"):
+        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,
+                )
+
+
+def _build_output_config_card():
+    """Build the Output Configuration card (appears after simulation, not for QPU)."""
+    with vuetify3.VCard(v_if="simulation_has_run && backend_type !== 'QPU'", classes="mb-1", style="font-size: 0.8rem;"):
+        with vuetify3.VCardSubtitle("Output Configuration", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px; font-weight: 600; color: #1A1A1A;"):
+            with vuetify3.VCardText(classes="py-1 px-2", style="color: #1A1A1A;"):
+                with vuetify3.VRadioGroup(v_model=("output_type", "Surface Plot"), row=True, density="compact", color="primary"):
+                    vuetify3.VRadio(label="Surface", value="Surface Plot", style="font-weight: 500;")
+                    vuetify3.VRadio(label="Time Series", value="Time Series Plot", style="font-weight: 500;")
+                
+                # Surface Plot options
+                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", style="font-weight: 500;")
+                    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="DOWNLOAD", color="primary", variant="tonal", block=True, classes="mt-1")
+                        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)
+                
+                # Time Series options
+                with vuetify3.VContainer(v_if="output_type === 'Time Series Plot'", classes="pa-0"):
+                    vuetify3.VSelect(v_model=("timeseries_field", "Ez"), items=("timeseries_field_options", ["All", "Ez", "Hx", "Hy"]), label="Field Component", density="compact", color="primary", style="font-weight: 500;")
+                    vuetify3.VTextarea(
+                        v_model=("timeseries_points", "(0.5, 0.5)"),
+                        label="Monitor Position(s) (x, y) in [0,1]",
+                        hint="e.g., (0.50, 0.50) or multiple comma-separated pairs",
+                        rows=2,
+                        auto_grow=True,
+                        color="primary",
+                        style="font-weight: 500;",
+                    )
+                    vuetify3.VAlert(
+                        v_if="timeseries_point_info",
+                        type="info",
+                        variant="tonal",
+                        density="compact",
+                        children=["{{ timeseries_point_info }}"],
+                        classes="mt-1",
+                        style="white-space: pre-line;",
+                    )
+                    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="DOWNLOAD", color="primary", variant="tonal", block=True, classes="mt-1")
+                        with vuetify3.VList(density="compact"):
+                            vuetify3.VListItem(title="Download CSV", prepend_icon="mdi-download", click=export_sim_timeseries_csv)
+                            vuetify3.VListItem(title="Download PNG", prepend_icon="mdi-image", click=export_sim_timeseries_png)
+                            vuetify3.VListItem(title="Download HTML", prepend_icon="mdi-file-html", click=export_sim_timeseries_html)
+
+
+def _build_main_plot_area():
+    """Build the main plot area (PyVista for Simulator)."""
+    with vuetify3.VCard(
+        v_if="geometry_selection && (backend_type !== 'QPU' || !qpu_ts_ready)",
+        classes="mb-1 flex-grow-1 d-flex flex-column",
+        style="min-height: 0;",
+    ):
+        # Running indicator
+        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")
+        
+        # Geometry preview (no excitation selected yet)
+        with vuetify3.VContainer(
+            v_if="!is_running && geometry_selection && !dist_type",
+            fluid=True,
+            classes="pa-0 flex-grow-1 d-flex align-center justify-center",
+            style="width: 100%; min-height: 560px;",
+        ):
+            geometry_preview_widget = plotly_widgets.Figure(
+                figure=_build_geometry_placeholder("Select a geometry to preview."),
+                responsive=True,
+                style="width: 100%; height: 100%;",
+            )
+            ctrl.geometry_preview_update = geometry_preview_widget.update
+        
+        # Excitation preview (before simulation runs)
+        with vuetify3.VContainer(
+            v_if="!is_running && dist_type && !simulation_has_run",
+            fluid=True,
+            classes="pa-0 flex-grow-1 d-flex align-center justify-center",
+            style="width: 100%; min-height: 580px;",
+        ):
+            excitation_preview_widget = plotly_widgets.Figure(
+                figure=_build_excitation_placeholder("Select an excitation to preview."),
+                responsive=True,
+                style="width: 100%; height: 100%;",
+            )
+            ctrl.excitation_preview_update = excitation_preview_widget.update
+        
+        # Surface Plot: PyVista view
+        with vuetify3.VContainer(v_if="!is_running && simulation_has_run && output_type === 'Surface Plot'", fluid=True, classes="pa-0", style=("pyvista_view_style", "aspect-ratio: 1 / 1; width: 100%;")):
+            view = plotter_ui(plotter)
+            ctrl.view_update = view.update
+        
+        # Time Series: Plotly figure
+        with vuetify3.VContainer(v_if="!is_running && simulation_has_run && output_type === 'Time Series Plot'", fluid=True, classes="d-flex align-center justify-center pa-2", style="overflow: hidden;"):
+            sim_ts = plotly_widgets.Figure(
+                figure=go.Figure(layout=dict(width=900, height=660)),
+                responsive=False,
+                style="width: 900px; height: 660px;",
+            )
+            ctrl.sim_ts_update = sim_ts.update
+        
+        # Time slider for surface plot
+        with vuetify3.VContainer(v_if="simulation_has_run && output_type === 'Surface Plot' && backend_type !== 'QPU'", fluid=True, classes="pa-0 mt-2"):
+            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")
+
+
+def _build_qpu_plot_area():
+    """Build the QPU plot area (Plotly time series)."""
+    with vuetify3.VCard(v_if="geometry_selection && backend_type === 'QPU' && (is_running || qpu_ts_ready)", classes="flex-grow-1", style="min-height: 0;"):
+        # Running indicator
+        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 QPU...", classes="mt-4")
+        
+        # QPU timeseries with toolbar
+        with vuetify3.VContainer(v_if="!is_running && qpu_ts_ready", fluid=True, classes="pa-2"):
+            with vuetify3.VToolbar(density="compact", flat=True, color="transparent", classes="px-0"):
+                vuetify3.VSelect(
+                    label="Component",
+                    v_model=("qpu_plot_filter", "All"),
+                    items=("qpu_plot_field_options", ["All"]),
+                    density="compact",
+                    color="primary",
+                    hide_details=True,
+                    style="max-width: 180px; margin-right: 8px;",
+                    disabled=("!qpu_ts_ready", True),
+                    update_modelValue=(ctrl.qpu_set_plot_filter, "[$event]")
+                )
+                vuetify3.VSelect(
+                    label="Position",
+                    v_model=("qpu_plot_position_filter", "All positions"),
+                    items=("qpu_plot_position_options", ["All positions"]),
+                    density="compact",
+                    color="primary",
+                    hide_details=True,
+                    style="max-width: 200px; margin-right: 8px;",
+                    disabled=("!qpu_ts_ready", True),
+                    update_modelValue=(ctrl.qpu_set_plot_position_filter, "[$event]")
+                )
+                vuetify3.VSpacer()
+                vuetify3.VBtn(
+                    text="Clear Selection",
+                    color="secondary",
+                    variant="text",
+                    click=ctrl.on_qpu_ts_clear,
+                    disabled=("!qpu_ts_ready", True),
+                )
+                with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
+                    with vuetify3.Template(v_slot_activator="{ props }"):
+                        vuetify3.VBtn(
+                            v_bind="props",
+                            text="DOWNLOAD",
+                            color="primary",
+                            variant="tonal",
+                            disabled=("!qpu_ts_ready", True),
+                        )
+                    with vuetify3.VList(density="compact"):
+                        vuetify3.VListItem(title="Download CSV", prepend_icon="mdi-download", click=export_qpu_timeseries_csv, disabled=("!qpu_ts_ready", True))
+                        vuetify3.VListItem(title="Download PNG", prepend_icon="mdi-image", click=export_qpu_timeseries_png, disabled=("!qpu_ts_ready", True))
+                        vuetify3.VListItem(title="Download HTML", prepend_icon="mdi-file-html", click=export_qpu_timeseries_html, disabled=("!qpu_ts_ready", True))
+            
+            trame_html.Div(style="height: 6px;")
+            
+            # Plotly figure for QPU timeseries
+            qpu_ts_widget = plotly_widgets.Figure(
+                figure=go.Figure(layout=dict(width=900, height=660)),
+                responsive=False,
+                style=("qpu_plot_style", "display: none; width: 900px; height: 660px; margin: 0 auto;"),
+                click=ctrl.on_qpu_ts_click,
+            )
+            ctrl.qpu_ts_update = qpu_ts_widget.update
+
+
+def _build_no_geometry_placeholder():
+    """Build placeholder when no geometry is 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.")
+
+
+def _build_status_console():
+    """Build the Status/Console card."""
+    with vuetify3.VCard(classes="mt-2", style="font-size: 0.8rem;"):
+        with vuetify3.VCardTitle("Status", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+            pass
+        with vuetify3.VCardText(classes="py-1 px-2", style="height: 150px; overflow-y: auto; background-color: #f5f5f5; font-family: monospace;"):
+            vuetify3.VTextarea(
+                v_model=("console_output", ""),
+                readonly=True,
+                auto_grow=False,
+                rows=6,
+                variant="plain",
+                hide_details=True,
+                style="font-family: monospace; width: 100%; height: 100%;"
+            )
+
+
+def _build_status_window():
+    """Build the floating status window (bottom right)."""
+    with vuetify3.VCard(
+        v_if="status_visible",
+        style="position: fixed; bottom: 16px; right: 16px; z-index: 1000; min-width: 320px; max-width: 450px;",
+        elevation=8
+    ):
+        with vuetify3.VCardTitle(classes="d-flex align-center", style="font-size: 0.95rem; padding: 8px 12px;"):
+            vuetify3.VIcon("mdi-information-outline", size="small", classes="mr-2")
+            trame_html.Span("Simulation Status")
+            vuetify3.VSpacer()
+            vuetify3.VBtn(
+                icon="mdi-close",
+                size="x-small",
+                variant="text",
+                click="status_visible = false"
+            )
+        vuetify3.VDivider()
+        with vuetify3.VCardText(classes="py-2 px-3"):
+            vuetify3.VAlert(
+                type=("status_type", "info"),
+                variant="tonal",
+                density="compact",
+                children=["{{ status_message }}"]
+            )
+            with vuetify3.VContainer(v_if="show_progress", classes="pa-0 mt-2"):
+                vuetify3.VProgressLinear(
+                    model_value=("simulation_progress", 0),
+                    color="primary",
+                    height=6,
+                    striped=True
+                )
+                trame_html.Div(
+                    "{{ simulation_progress }}% complete",
+                    classes="text-caption text-center mt-1",
+                    style="font-size: 0.75rem;"
+                )

em/utils.py

@@ -0,0 +1,187 @@
+"""
+EM Embedded - Utility Functions
+
+Contains shared utilities for grid snapping, coordinate helpers,
+regex patterns, and logo loading.
+"""
+import re
+import os
+import base64
+import numpy as np
+
+__all__ = [
+    "SAMPLE_PAIR_RE",
+    "nearest_node_index",
+    "snap_samples_to_grid",
+    "nearest_gridline",
+    "load_logo_data_uri",
+    "normalized_position_label",
+    "format_grid_label",
+]
+
+# Regex pattern for parsing coordinate pairs like "(0.5, 0.5)"
+SAMPLE_PAIR_RE = re.compile(r"\(\s*([-+]?\d*\.?\d+)\s*,\s*([-+]?\d*\.?\d+)\s*\)")
+
+
+def nearest_node_index(x: float, y: float, nx: int, ny: int = None) -> tuple:
+    """Map normalized [0,1] coordinates to nearest node index on an nx×ny grid."""
+    if ny is None:
+        ny = nx
+    ix = int(round(x * (nx - 1)))
+    iy = int(round(y * (ny - 1)))
+    ix = max(0, min(nx - 1, ix))
+    iy = max(0, min(ny - 1, iy))
+    return ix, iy
+
+
+def nearest_gridline(val: float, nx: int) -> float:
+    """Snap a value to the nearest gridline."""
+    return round(val * (nx - 1)) / (nx - 1) if nx > 1 else val
+
+
+def snap_samples_to_grid(sample_str: str, nx: int) -> tuple:
+    """
+    Parse and snap sample points to grid.
+    
+    Returns:
+        tuple: (snapped_gridpoints_str, display_info_str)
+    """
+    if nx is None or nx < 2:
+        return "", ""
+    
+    matches = SAMPLE_PAIR_RE.findall(sample_str)
+    if not matches:
+        return "", "Enter sample position(s) as (x, y) pairs in [0,1] x [0,1]."
+    
+    snapped = []
+    info_parts = []
+    
+    for x_str, y_str in matches:
+        try:
+            x_norm = float(x_str)
+            y_norm = float(y_str)
+            # Clamp to [0, 1]
+            x_norm = max(0.0, min(1.0, x_norm))
+            y_norm = max(0.0, min(1.0, y_norm))
+            # Snap to grid
+            ix = int(round(x_norm * (nx - 1)))
+            iy = int(round(y_norm * (nx - 1)))
+            ix = max(0, min(nx - 1, ix))
+            iy = max(0, min(nx - 1, iy))
+            snapped.append((ix, iy))
+            # Compute snapped normalized coords for display
+            x_snapped = ix / (nx - 1) if nx > 1 else 0.0
+            y_snapped = iy / (nx - 1) if nx > 1 else 0.0
+            changed = (abs(x_norm - x_snapped) > 1e-9 or abs(y_norm - y_snapped) > 1e-9)
+            descriptor = "adjusted" if changed else "aligned"
+            info_parts.append(f"Input ({x_norm:.3f}, {y_norm:.3f}) {descriptor} to ({x_snapped:.3f}, {y_snapped:.3f}) → ({ix}, {iy})")
+        except (ValueError, ZeroDivisionError):
+            continue
+    
+    gridpoints_str = ", ".join(f"({ix}, {iy})" for ix, iy in snapped)
+    info_str = "\n".join(info_parts)
+    
+    return gridpoints_str, info_str
+
+
+def normalized_position_label(px: int, py: int, gw: int, gh: int) -> str:
+    """Create a normalized position label like 'Position (0.500, 0.500)'."""
+    px_i, py_i = int(px), int(py)
+    denom_x = float(max(gw - 1, 1))
+    denom_y = float(max(gh - 1, 1))
+    x_norm = px_i / denom_x
+    y_norm = py_i / denom_y
+    return f"Position ({x_norm:.3f}, {y_norm:.3f})"
+
+
+def format_grid_label(px: int, py: int, field: str = None, nx: int = None, label_map: dict = None) -> str:
+    """Format a grid position label, optionally using a label map."""
+    px_i, py_i = int(px), int(py)
+    
+    if label_map and field:
+        label = label_map.get((str(field), px_i, py_i))
+        if label:
+            return label
+    
+    if label_map:
+        for (fld, gx, gy), label in label_map.items():
+            if gx == px_i and gy == py_i:
+                return label
+    
+    if nx:
+        denom = float(max(int(nx) - 1, 1))
+        return f"Position ({px_i / denom:.3f}, {py_i / denom:.3f})"
+    
+    return f"Position ({px_i}, {py_i})"
+
+
+def load_logo_data_uri() -> str:
+    """Load the Synopsys logo as a data URI."""
+    base_dir = os.path.dirname(os.path.dirname(__file__))  # quantum_embedded folder
+    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"),
+        # Also check in parent quantum folder
+        os.path.join(os.path.dirname(base_dir), "quantum", "ansys-part-of-synopsys-logo.svg"),
+    ]
+    
+    for p in candidates:
+        if os.path.exists(p):
+            ext = os.path.splitext(p)[1].lower()
+            if ext == ".svg":
+                mime = "image/svg+xml"
+            elif ext == ".png":
+                mime = "image/png"
+            else:
+                mime = "image/jpeg"
+            try:
+                with open(p, "rb") as f:
+                    b64 = base64.b64encode(f.read()).decode("ascii")
+                return f"data:{mime};base64,{b64}"
+            except Exception:
+                continue
+    
+    return None
+
+
+def install_synopsys_plotly_theme():
+    """Install a Synopsys-aligned Plotly theme."""
+    import plotly.io as pio
+    import plotly.graph_objects as go
+    
+    base = go.layout.Template(pio.templates["plotly_white"])
+    base.layout.update(
+        font=dict(
+            family="Inter, Segoe UI, Roboto, Helvetica, Arial, sans-serif",
+            size=13,
+            color="#1A1A1A",
+        ),
+        paper_bgcolor="#FFFFFF",
+        plot_bgcolor="#FFFFFF",
+        colorway=["#5F259F", "#7A3DB5", "#AE8BD8", "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728"],
+        hoverlabel=dict(bgcolor="#FFFFFF", bordercolor="#5F259F", font=dict(color="#1A1A1A")),
+        legend=dict(orientation="h", x=1, xanchor="right", y=1.02, yanchor="bottom", title_text=""),
+        margin=dict(l=40, r=20, t=40, b=40),
+    )
+    base.layout.xaxis.update(
+        showgrid=True,
+        gridcolor="rgba(95,37,159,0.1)",
+        zeroline=False,
+        linecolor="rgba(0,0,0,.2)",
+        ticks="outside",
+        tickformat=".2f",
+    )
+    base.layout.yaxis.update(
+        showgrid=True,
+        gridcolor="rgba(95,37,159,0.1)",
+        zeroline=True,
+        zerolinecolor="rgba(0,0,0,.25)",
+        linecolor="rgba(0,0,0,.2)",
+        ticks="outside",
+        tickformat=".3g",
+    )
+    pio.templates["syn_white"] = base
+    pio.templates.default = "syn_white"
+

pages/__init__.py

@@ -1,4 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-"""
-EM Page - Embedded Mode Wrapper
-
-This module provides the EM experience for the unified app.
-It uses the embedded module instead of spawning a subprocess.
-"""
-from trame_vuetify.widgets import vuetify3
-from trame.widgets import html as trame_html
-import os
-import sys
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
-
-try:
-    import em_embedded
-    _EM_AVAILABLE = True
-except ImportError as e:
-    _EM_AVAILABLE = False
-    _EM_ERROR = str(e)
-
-
-def build(server):
-    """Build the EM UI using the embedded module."""
-    if not _EM_AVAILABLE:
-        with vuetify3.VContainer(fluid=True, classes="pa-4"):
-            trame_html.Div(
-                f"EM module failed to load: {_EM_ERROR}",
-                style="color: #b00020; padding: 12px;"
-            )
-        return
-    
-    # Set the server and initialize state
-    em_embedded.set_server(server)
-    em_embedded.init_state()
-    
-    # Build the UI
-    em_embedded.build_ui()
-
-
-def stop():
-    """Stop any running EM processes (no-op in embedded mode)."""
-    pass

pages/em_page_subprocess.py

@@ -1,70 +0,0 @@
-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
-_EM_HOST = os.environ.get("EM_HOST", "127.0.0.1")
-_EM_IFRAME_SRC = os.environ.get("EM_IFRAME_SRC", "").strip()
-
-
-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()
-    # Prevent hosted platforms from forcing the subprocess to bind to $PORT
-    env.pop("PORT", None)
-    env.pop("HF_PORT", None)
-    # Port used by iframe
-    env.setdefault("EM_APP_PORT", env.get("PORT_EM", "8701"))
-    env.setdefault("EM_HOST", _EM_HOST)
-    # 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"))
-    host = os.environ.get("EM_HOST", _EM_HOST)
-    iframe_src = _EM_IFRAME_SRC or f"http://{host}:{port}/"
-    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-        trame_html.Iframe(
-            src=("em_iframe_src", iframe_src),
-            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

@@ -1,43 +0,0 @@
-"""
-QLBM Page - Embedded Mode Wrapper
-
-This module provides the QLBM experience for the unified app.
-It uses the embedded module instead of spawning a subprocess.
-"""
-from trame_vuetify.widgets import vuetify3
-from trame.widgets import html as trame_html
-import os
-import sys
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
-
-try:
-    import qlbm_embedded
-    _QLBM_AVAILABLE = True
-except ImportError as e:
-    _QLBM_AVAILABLE = False
-    _QLBM_ERROR = str(e)
-
-
-def build(server):
-    """Build the QLBM UI using the embedded module."""
-    if not _QLBM_AVAILABLE:
-        with vuetify3.VContainer(fluid=True, classes="pa-4"):
-            trame_html.Div(
-                f"QLBM module failed to load: {_QLBM_ERROR}",
-                style="color: #b00020; padding: 12px;"
-            )
-        return
-    
-    # Set the server and initialize state
-    qlbm_embedded.set_server(server)
-    qlbm_embedded.init_state()
-    
-    # Build the UI
-    qlbm_embedded.build_ui()
-
-
-def stop():
-    """Stop any running QLBM processes (no-op in embedded mode)."""
-    pass

pages/qlbm_page_subprocess.py

@@ -1,128 +0,0 @@
-"""Embedded QLBM fluids page wrapper.
-Starts the standalone qlbm.py server in a background subprocess so the main
-multi-page app only needs `python app.py`.
-
-Environment variables:
-  QLBM_APP_PORT / PORT_QLBM -> port (default 8702)
-  QLBM_HOST                 -> host interface (default 127.0.0.1)
-"""
-from __future__ import annotations
-import os, sys, subprocess, atexit
-from trame_vuetify.widgets import vuetify3
-from trame.widgets import html as trame_html
-import shutil
-
-_gpu_status = {
-    "checked": False,
-    "available": False,
-    "reason": ""
-}
-
-
-def _detect_gpu_availability(force_recheck=False):
-    """Best-effort CUDA GPU detection for hosted environments."""
-    global _gpu_status
-    if _gpu_status["checked"] and not force_recheck:
-        return _gpu_status["available"], _gpu_status["reason"]
-
-    allow_missing = os.environ.get("QLBM_IGNORE_GPU_CHECK", "0") == "1"
-    if allow_missing:
-        _gpu_status.update({"checked": True, "available": True, "reason": ""})
-        return True, ""
- 
-    def _has_devices(val: str | None) -> bool:
-        if not val:
-            return False
-        lowered = val.strip().lower()
-        return lowered not in ("", "none", "nodevfiles", "-1")
-
-    nvidia_devices = os.environ.get("NVIDIA_VISIBLE_DEVICES")
-    cuda_devices = os.environ.get("CUDA_VISIBLE_DEVICES")
-    saw_env_nvidia = _has_devices(nvidia_devices)
-    saw_env_cuda = _has_devices(cuda_devices)
-
-    # Heuristics: presence of device files or nvidia-smi
-    has_proc_entry = os.path.exists("/proc/driver/nvidia/version")
-    has_nvidia_smi = shutil.which("nvidia-smi") is not None
-    has_gpu = (saw_env_nvidia or saw_env_cuda or has_proc_entry or has_nvidia_smi)
-
-    if has_gpu:
-        _gpu_status.update({"checked": True, "available": True, "reason": ""})
-        return True, ""
-
-    reason = "No NVIDIA GPU detected (CUDA_VISIBLE_DEVICES/NVIDIA_VISIBLE_DEVICES unset and no nvidia drivers present)."
-    _gpu_status.update({"checked": True, "available": False, "reason": reason})
-    return False, reason
-
-_qlbm_proc = None
-_QLBM_HOST = os.environ.get("QLBM_HOST", "127.0.0.1")
-_QLBM_IFRAME_SRC = os.environ.get("QLBM_IFRAME_SRC", "").strip()
-
-
-def _kill_qlbm_process():
-    global _qlbm_proc
-    if _qlbm_proc and _qlbm_proc.poll() is None:
-        try:
-            _qlbm_proc.terminate()
-            _qlbm_proc.wait(timeout=2)
-        except Exception:
-            try:
-                _qlbm_proc.kill()
-            except Exception:
-                pass
-    _qlbm_proc = None
-
-
-def _ensure_qlbm_process_started():
-    global _qlbm_proc
-    if _qlbm_proc and _qlbm_proc.poll() is None:
-        return
-    _kill_qlbm_process()
-    base_dir = os.path.dirname(os.path.dirname(__file__))
-    qlbm_path = os.path.join(base_dir, "qlbm.py")
-    env = os.environ.copy()
-    env.pop("PORT", None)
-    env.pop("HF_PORT", None)
-    env.setdefault("QLBM_APP_PORT", env.get("PORT_QLBM", "8702"))
-    env.setdefault("QLBM_HOST", _QLBM_HOST)
-    py = sys.executable or "python"
-    _qlbm_proc = subprocess.Popen([py, qlbm_path], cwd=base_dir, env=env)
-
-
-atexit.register(_kill_qlbm_process)
-
-
-def build(server):  # signature matches app.py expectation
-    if os.environ.get("DISABLE_SUBAPPS", "").strip() == "1":
-        with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-            trame_html.Div(
-                "This tab is disabled in single-port environments. Please run locally to enable the QLBM view.",
-                style="padding:12px;color:#555;",
-            )
-        return
-    gpu_ok, gpu_reason = _detect_gpu_availability()
-    if not gpu_ok:
-        with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-            trame_html.Div(
-                "QLBM requires an NVIDIA CUDA-capable GPU, which is not available in this environment.",
-                style="padding:12px;color:#b00020;font-weight:600;",
-            )
-            trame_html.Div(
-                f"Details: {gpu_reason} Run the FLUIDS tab locally with a GPU or set QLBM_IGNORE_GPU_CHECK=1 to bypass this guard.",
-                style="padding:8px 12px;color:#555;",
-            )
-        return
-    _ensure_qlbm_process_started()
-    port = os.environ.get("QLBM_APP_PORT", os.environ.get("PORT_QLBM", "8702"))
-    host = os.environ.get("QLBM_HOST", _QLBM_HOST)
-    iframe_src = _QLBM_IFRAME_SRC or f"http://{host}:{port}/"
-    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-        trame_html.Iframe(
-            src=("qlbm_iframe_src", iframe_src),
-            style="border:0;width:100%;height:100%;min-height:0;",
-        )
-        trame_html.Div(
-            "If the QLBM view is blank, wait a few seconds for the subprocess to start.",
-            style="color:rgba(0,0,0,.6);padding:6px;",
-        )
-

qlbm.py

@@ -1,1501 +0,0 @@
-import os
-os.environ["OMP_NUM_THREADS"] = "1"
-
-import numpy as np
-import math
-import time
-import tempfile
-from datetime import datetime
-from pathlib import Path
-import plotly.graph_objects as go
-import pyvista as pv
-from trame.app import get_server
-from trame_vuetify.ui.vuetify3 import SinglePageLayout
-from trame_vuetify.widgets import vuetify3
-from trame.widgets import html  # <--- IMPORT ADDED HERE
-from trame_plotly.widgets import plotly as plotly_widgets
-from pyvista.trame.ui import plotter_ui
-
-
-def _env_flag(name: str) -> bool:
-    value = os.environ.get(name)
-    return str(value).lower() in {"1", "true", "yes", "on"} if value is not None else False
-
-
-def _should_disable_quantum_backend():
-    if _env_flag("FORCE_ENABLE_CUDAQ"):
-        return False, ""
-
-    reasons = []
-    if _env_flag("DISABLE_CUDAQ"):
-        reasons.append("disabled via DISABLE_CUDAQ=1")
-
-    hf_space = os.environ.get("SPACE_ID") or os.environ.get("HF_SPACE_ID")
-    # if hf_space:
-    #     reasons.append("running inside Hugging Face Spaces (CPU runtime)")
-
-    cuda_visible = os.environ.get("CUDA_VISIBLE_DEVICES")
-    if cuda_visible is not None and cuda_visible.strip() in {"", "-1"}:
-        reasons.append("no CUDA device exposed (CUDA_VISIBLE_DEVICES is empty)")
-
-    nvidia_visible = os.environ.get("NVIDIA_VISIBLE_DEVICES")
-    if nvidia_visible is not None and nvidia_visible.strip() in {"", "void"}:
-        reasons.append("no NVIDIA device exposed (NVIDIA_VISIBLE_DEVICES is empty)")
-
-    if reasons:
-        msg = "; ".join(reasons)
-        return True, f"Quantum backend disabled because {msg}. Set FORCE_ENABLE_CUDAQ=1 to override."
-
-    return False, ""
-
-
-simulate_qlbm_3D_and_animate = None
-_SIMULATION_BACKEND_DISABLED, _SIMULATION_DISABLED_REASON = _should_disable_quantum_backend()
-_CPU_DEMO_AVAILABLE = True
-_CPU_DEMO_MAX_GRID = 48
-
-if not _SIMULATION_BACKEND_DISABLED:
-    try:
-        from fluid3d_pyvista import simulate_qlbm_3D_and_animate  # type: ignore
-    except ImportError:
-        try:
-            from quantum.fluid3d_pyvista import simulate_qlbm_3D_and_animate  # type: ignore
-        except ImportError as exc:
-            _SIMULATION_DISABLED_REASON = "Simulation module not found."
-            simulate_qlbm_3D_and_animate = None
-            print(f"Warning: {exc}")
-    except Exception as exc:  # pragma: no cover - defensive guard for HF runtime
-        _SIMULATION_DISABLED_REASON = f"Failed to load CUDA-Q backend: {exc}"
-        simulate_qlbm_3D_and_animate = None
-else:
-    _SIMULATION_DISABLED_REASON = _SIMULATION_DISABLED_REASON or "Quantum backend disabled by environment settings."
-
-_SIMULATION_BACKEND_READY = simulate_qlbm_3D_and_animate is not None
-if not _SIMULATION_BACKEND_READY and _SIMULATION_DISABLED_REASON:
-    print(f"Warning: {_SIMULATION_DISABLED_REASON}")
-
-if _SIMULATION_BACKEND_READY:
-    _SIMULATION_BACKEND_NOTE = ""
-    _SIMULATION_MODE_LABEL = "Quantum CUDA-Q backend"
-else:
-    if _CPU_DEMO_AVAILABLE:
-        reason = _SIMULATION_DISABLED_REASON or "Quantum backend is unavailable in this environment."
-        _SIMULATION_BACKEND_NOTE = (
-            f"CPU demo mode active ({reason}). Results are approximate. "
-            "Set FORCE_ENABLE_CUDAQ=1 on a GPU host to use the quantum backend."
-        )
-        _SIMULATION_MODE_LABEL = "CPU demo backend"
-    else:
-        _SIMULATION_BACKEND_NOTE = _SIMULATION_DISABLED_REASON or "Simulation backend unavailable."
-        _SIMULATION_MODE_LABEL = "Unavailable"
-
-_SIMULATION_CAN_RUN = _SIMULATION_BACKEND_READY or _CPU_DEMO_AVAILABLE
-
-# --- Server Setup ---
-server = get_server()
-state, ctrl = server.state, server.controller
-
-def log_to_console(message):
-    timestamp = datetime.now().strftime("%H:%M:%S")
-    new_line = f"[{timestamp}] {message}\n"
-    state.console_output = (state.console_output or "") + new_line
-
-pv.OFF_SCREEN = True
-
-# --- State Initialization ---
-GRID_SIZES = ["8", "16", "32", "64", "128"]
-
-_WORKFLOW_BASE_STYLE = "font-size: 0.8rem; border: 1px solid transparent; transition: box-shadow 0.2s ease;"
-
-state.update({
-    "console_output": "Console initialized.\n",
-    "status_visible": True,
-    "status_message": "Ready",
-    "status_type": "info",
-    "simulation_progress": 0,
-    "show_progress": False,
-    "dist_modes": ["Sinusoidal", "Gaussian"], 
-    "dist_type": None, 
-    "nx_slider_index": 2,    # Default to 32
-    "nx": 32,
-    "show_edges": False,
-    "custom_dist_params": False,
-    "sine_k_x": 1.0,
-    "sine_k_y": 1.0,
-    "sine_k_z": 1.0,
-    "gauss_cx": 16,
-    "gauss_cy": 16,
-    "gauss_cz": 16,
-    "gauss_sigma": 6.0,
-    # Added from qlbm.py
-    "problems_selection": None,
-    "geometry_selection": None,
-    "domain_L": 1.0,
-    "domain_W": 1.0,
-    "domain_H": 1.0,
-    # Added for new sections
-    "boundary_condition": "Periodic",
-    "advecting_field": None,
-    "show_advect_params": False,
-    "vx_expr": "0.2",
-    "vy_expr": "-0.15",
-    "vz_expr": "0.3",
-    "grid_index": 2,
-    "grid_size": 32,
-    "time_steps": 100,
-    "backend_type": None,
-    "selected_simulator": "IBM Qiskit simulator",
-    "selected_qpu": "IBM QPU",
-    "is_running": False,
-    "run_error": "",
-    "qubit_grid_info": "Grid Size: 32 × 32 × 32",
-    "qubit_warning": "",
-    # Animation state
-    "simulation_has_run": False,
-    "time_val": 0,
-    "max_time_step": 0,
-    "time_slider_labels": [],  # Formatted time labels for slider thumb
-    "simulation_backend_ready": _SIMULATION_CAN_RUN,
-    "simulation_backend_note": _SIMULATION_BACKEND_NOTE,
-    "simulation_backend_mode": _SIMULATION_MODE_LABEL,
-    # Workflow guidance styles
-    "workflow_step": 0,
-    "overview_card_style": _WORKFLOW_BASE_STYLE,
-    "geometry_card_style": _WORKFLOW_BASE_STYLE,
-    "distribution_card_style": _WORKFLOW_BASE_STYLE,
-    "advect_card_style": _WORKFLOW_BASE_STYLE,
-    "meshing_card_style": _WORKFLOW_BASE_STYLE,
-    "backend_card_style": _WORKFLOW_BASE_STYLE,
-})
-
-_WORKFLOW_CARD_KEYS = [
-    "overview_card_style",
-    "distribution_card_style",
-    "advect_card_style",
-    "backend_card_style",
-]
-
-_PROBLEM_GEOMETRY_MAP = {
-    "Scalar advection-diffusion in a box": "Cube",
-    "Laminar flow & heat transfer for a heated body in water.": "Rectangular domain with a heated box (3D)",
-}
-
-
-def _workflow_highlight_style(active: bool) -> str:
-    accent = "border: 2px solid #5F259F; box-shadow: 0 0 12px rgba(95,37,159,0.45); background-color: rgba(95,37,159,0.02);"
-    return f"{_WORKFLOW_BASE_STYLE} {accent}" if active else _WORKFLOW_BASE_STYLE
-
-
-def _determine_workflow_step() -> int:
-    if not state.problems_selection:
-        return 0
-    if not state.dist_type:
-        return 1
-    if not state.advecting_field:
-        return 2
-    if not state.backend_type:
-        return 3
-    return len(_WORKFLOW_CARD_KEYS)
-
-
-def _apply_workflow_highlights(step_index: int):
-    state.workflow_step = step_index
-    for idx, key in enumerate(_WORKFLOW_CARD_KEYS):
-        highlight = idx == step_index if step_index < len(_WORKFLOW_CARD_KEYS) else False
-        setattr(state, key, _workflow_highlight_style(highlight))
-
-
-_apply_workflow_highlights(0)
-
-# --- Plotter Setup ---
-plotter = pv.Plotter()
-current_grid = None
-current_grid_size = 0
-_picking_enabled = False
-_INFO_TEXT_ACTOR = "pick_info_text"
-
-# Global simulation data storage
-simulation_data_frames = []
-simulation_times = []
-current_grid_object = None
-
-def _set_pick_text(message: str):
-    try:
-        plotter.remove_actor(_INFO_TEXT_ACTOR)
-    except Exception:
-        pass
-    plotter.add_text(message, name=_INFO_TEXT_ACTOR, position="lower_left", font_size=12, color="black")
-
-def _ensure_point_picking(callback):
-    global _picking_enabled
-    if not _picking_enabled:
-        plotter.enable_point_picking(callback=callback, show_message=False, point_size=10, color="red")
-        _picking_enabled = True
-
-def get_initial_distribution_figure(distribution_type: str, grid_size: int = 32, show_edges: bool = False):
-    """
-    Generates a 3D Plotly isosurface figure for a given distribution type.
-    """
-    N = grid_size
-    
-    # --- 1. Define the mathematical functions ---
-    if distribution_type == "Sinusoidal":
-        kx = max(1.0, round(state.sine_k_x))
-        ky = max(1.0, round(state.sine_k_y))
-        kz = max(1.0, round(state.sine_k_z))
-        
-        selected_func = lambda x, y, z: \
-            np.sin(x * 2 * np.pi * kx / N) * \
-            np.sin(y * 2 * np.pi * ky / N) * \
-            np.sin(z * 2 * np.pi * kz / N) + 1
-        title = f"Sinusoidal Distribution (N={N})"
-
-    elif distribution_type == "Gaussian":
-        cx, cy, cz = state.gauss_cx, state.gauss_cy, state.gauss_cz
-        sigma = state.gauss_sigma if state.gauss_sigma > 0 else 0.1
-        
-        selected_func = lambda x, y, z: \
-            np.exp(-((x - cx)**2 / (2 * sigma**2) +
-                     (y - cy)**2 / (2 * sigma**2) +
-                     (z - cz)**2 / (2 * sigma**2))) * 1.8 + 0.2
-        title = f"Gaussian Distribution (N={N})"
-
-    else:
-        return go.Figure()
-
-    # --- 2. Create the 3D grid ---
-    x_indices = np.linspace(0, 1, N)
-    y_indices = np.linspace(0, 1, N)
-    z_indices = np.linspace(0, 1, N)
-
-    X, Y, Z = np.meshgrid(x_indices, y_indices, z_indices, indexing='ij')
-
-    # --- 3. Calculate the distribution values at every point ---
-    xi = np.arange(0, N)
-    yi = np.arange(0, N)
-    zi = np.arange(0, N)
-    Xi, Yi, Zi = np.meshgrid(xi, yi, zi, indexing='ij')
-    values = selected_func(Xi, Yi, Zi)
-
-    # --- 4. Create the Plotly visualization ---
-    
-    # Default settings
-    isomin = np.min(values)
-    isomax = np.max(values)
-    surface_count = 5
-    
-    if distribution_type == "Sinusoidal":
-        # Avoid drawing the boundary plane at value=1.0
-        # Range is [0, 2]. 1.0 is the background.
-        # We use count=4 and slightly cropped range to avoid 1.0
-        isomin = 0.1
-        isomax = 1.9
-        surface_count = 4
-
-    data = [go.Isosurface(
-        x=X.flatten(),
-        y=Y.flatten(),
-        z=Z.flatten(),
-        value=values.flatten(),
-        isomin=isomin,
-        isomax=isomax,
-        surface_count=surface_count,
-        colorscale='Blues',
-        opacity=0.35,
-        caps=dict(x_show=False, y_show=False, z_show=False)
-    )]
-
-    if show_edges:
-        # Create grid lines using np.nan to separate segments
-        # 1. Lines along X (vary x, fixed y, z)
-        Y_yz, Z_yz = np.meshgrid(y_indices, z_indices, indexing='ij')
-        Y_flat, Z_flat = Y_yz.flatten(), Z_yz.flatten()
-        num_lines = len(Y_flat)
-        
-        xe = np.full(num_lines * 3, np.nan)
-        xe[0::3], xe[1::3] = 0, 1
-        ye = np.full(num_lines * 3, np.nan)
-        ye[0::3] = ye[1::3] = Y_flat
-        ze = np.full(num_lines * 3, np.nan)
-        ze[0::3] = ze[1::3] = Z_flat
-        
-        # 2. Lines along Y (vary y, fixed x, z)
-        X_xz, Z_xz = np.meshgrid(x_indices, z_indices, indexing='ij')
-        X_flat, Z_flat = X_xz.flatten(), Z_xz.flatten()
-        num_lines = len(X_flat)
-        
-        xe_y = np.full(num_lines * 3, np.nan)
-        xe_y[0::3] = xe_y[1::3] = X_flat
-        ye_y = np.full(num_lines * 3, np.nan)
-        ye_y[0::3], ye_y[1::3] = 0, 1
-        ze_y = np.full(num_lines * 3, np.nan)
-        ze_y[0::3] = ze_y[1::3] = Z_flat
-
-        # 3. Lines along Z (vary z, fixed x, y)
-        X_xy, Y_xy = np.meshgrid(x_indices, y_indices, indexing='ij')
-        X_flat, Y_flat = X_xy.flatten(), Y_xy.flatten()
-        num_lines = len(X_flat)
-        
-        xe_z = np.full(num_lines * 3, np.nan)
-        xe_z[0::3] = xe_z[1::3] = X_flat
-        ye_z = np.full(num_lines * 3, np.nan)
-        ye_z[0::3] = ye_z[1::3] = Y_flat
-        ze_z = np.full(num_lines * 3, np.nan)
-        ze_z[0::3], ze_z[1::3] = 0, 1
-
-        # Combine
-        x_all = np.concatenate([xe, xe_y, xe_z])
-        y_all = np.concatenate([ye, ye_y, ye_z])
-        z_all = np.concatenate([ze, ze_y, ze_z])
-
-        data.append(go.Scatter3d(
-            x=x_all, y=y_all, z=z_all,
-            mode='lines',
-            line=dict(color='black', width=1), # Black lines
-            opacity=0.22,                      # Reduced opacity
-            name='Grid Edges'
-        ))
-
-    fig = go.Figure(data=data)
-    
-    fig.update_layout(
-        title=title,
-        scene=dict(
-            xaxis=dict(backgroundcolor="white", showbackground=True, gridcolor="lightgrey", zerolinecolor="lightgrey", title='X'),
-            yaxis=dict(backgroundcolor="white", showbackground=True, gridcolor="lightgrey", zerolinecolor="lightgrey", title='Y'),
-            zaxis=dict(backgroundcolor="white", showbackground=True, gridcolor="lightgrey", zerolinecolor="lightgrey", title='Z'),
-        ),
-        margin=dict(l=0, r=0, b=0, t=40),
-        width=800,
-        height=700
-    )
-    return fig
-
-def update_view():
-    global current_grid, current_grid_size
-    
-    # If simulation has run, we don't update the preview
-    if state.simulation_has_run:
-        return
-
-    try:
-        N = int(state.nx)
-        distribution_type = state.dist_type
-        
-        # Update Plotly Preview
-        show_edges = state.show_edges
-        fig = get_initial_distribution_figure(distribution_type, N, show_edges)
-        if hasattr(ctrl, "preview_update"):
-            ctrl.preview_update(fig)
-        
-    except Exception as e:
-        print(f"Error: {e}")
-
-def on_pick_point(point, *_) -> None:
-    if point is None or current_grid_object is None: return
-    closest_id = current_grid_object.find_closest_point(point)
-    if closest_id == -1: return
-    values = current_grid_object.point_data.get('scalars')
-    if values is None: return
-
-    coords = current_grid_object.points[closest_id]
-    val = float(values[closest_id])
-    
-    x, y, z = coords
-    _set_pick_text(f"Position: ({x:.3f}, {y:.3f}, {z:.3f})\nValue: {val:.4g}")
-    ctrl.view_update()
-
-# --- Helpers for New Sections ---
-
-def update_qubit_3D_info(grid_size: int):
-    """Generate qubit requirement plot and info strings."""
-    try:
-        num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
-        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)
-        )
-        grid_display = f"Grid Size: {grid_size} × {grid_size} × {grid_size}"
-        warning = "⚠️ Warning: Grid sizes > 64 may exceed simulator/memory limits!" if grid_size > 64 else ""
-        return fig, grid_display, warning
-    except Exception:
-        return go.Figure(), "Grid Size: N/A", ""
-
-def set_velocity_preset(preset_name):
-    """Map velocity preset buttons to expression triplets."""
-    mapping = {
-        "Uniform": ("0.2", "-0.15", "0.3"),
-        "Swirl": ("0.3*sin(-2*pi*z)", "0.2", "0.3*sin(2*pi*x)"),
-        "Shear": ("abs(z-0.5)*1.2-0.3", "0", "0"),
-        "TGV": ("0.15*cos(2*pi*x)*sin(2*pi*y)*sin(2*pi*z)", "-0.3*sin(2*pi*x)*cos(2*pi*y)*sin(2*pi*z)", "0.15*sin(2*pi*x)*sin(2*pi*y)*cos(2*pi*z)"),
-    }
-    vx, vy, vz = mapping.get(preset_name, mapping["Uniform"])
-    state.advecting_field = preset_name
-    state.vx_expr = vx
-    state.vy_expr = vy
-    state.vz_expr = vz
-
-def make_velocity_func(expr):
-    """Convert a string expression into a function of (x, y, z)."""
-    def func(x, y, z):
-        # Safe-ish eval context with numpy functions
-        context = {
-            "x": x, "y": y, "z": z, 
-            "sin": np.sin, "cos": np.cos, "tan": np.tan,
-            "pi": np.pi, "abs": np.abs, "exp": np.exp, "sqrt": np.sqrt
-        }
-        try:
-            # Evaluate expression
-            return eval(str(expr), {"__builtins__": {}}, context)
-        except Exception as e:
-            print(f"Error evaluating velocity expression '{expr}': {e}")
-            # Return a safe default (scalar or array depending on input)
-            return np.zeros_like(x) if isinstance(x, np.ndarray) else 0.0
-    return func
-
-
-def _safe_velocity_sample(func) -> float:
-    try:
-        val = func(0.5, 0.5, 0.5)
-        if isinstance(val, np.ndarray):
-            val = float(np.mean(val))
-        return float(val)
-    except Exception:
-        return 0.0
-
-
-def _cpu_distribution_field(distribution_type: str, Xi, Yi, Zi, grid_size: int, drift, phase_fraction: float):
-    if distribution_type == "Sinusoidal":
-        kx = max(1.0, round(float(state.sine_k_x))) if hasattr(state, "sine_k_x") else 1.0
-        ky = max(1.0, round(float(state.sine_k_y))) if hasattr(state, "sine_k_y") else 1.0
-        kz = max(1.0, round(float(state.sine_k_z))) if hasattr(state, "sine_k_z") else 1.0
-        x_term = np.sin((np.mod(Xi + drift[0], grid_size)) * 2 * np.pi * kx / grid_size)
-        y_term = np.sin((np.mod(Yi + drift[1], grid_size)) * 2 * np.pi * ky / grid_size)
-        z_term = np.sin((np.mod(Zi + drift[2], grid_size)) * 2 * np.pi * kz / grid_size)
-        field = x_term * y_term * z_term + 1.0
-    else:
-        # Gaussian (default fallback)
-        nx_val = max(1.0, float(state.nx)) if hasattr(state, "nx") else float(grid_size)
-        cx = float(state.gauss_cx) if hasattr(state, "gauss_cx") else nx_val / 2
-        cy = float(state.gauss_cy) if hasattr(state, "gauss_cy") else nx_val / 2
-        cz = float(state.gauss_cz) if hasattr(state, "gauss_cz") else nx_val / 2
-        sigma = float(state.gauss_sigma) if hasattr(state, "gauss_sigma") else nx_val / 6
-        scale = (grid_size - 1) / nx_val if nx_val else 1.0
-        cx = cx * scale + drift[0]
-        cy = cy * scale + drift[1]
-        cz = cz * scale + drift[2]
-        sigma = max(1.0, sigma * scale)
-        field = np.exp(-(((Xi - cx) ** 2 + (Yi - cy) ** 2 + (Zi - cz) ** 2) / (2 * sigma ** 2))) * 1.8 + 0.2
-
-    modulation = 0.15 * np.sin(2 * np.pi * phase_fraction + (Xi + Yi + Zi) * np.pi / max(1, grid_size))
-    return field + modulation
-
-
-def _run_cpu_demo_simulation(grid_size: int, T: int, distribution_type: str, vx_func, vy_func, vz_func, progress_callback=None):
-    grid_size = int(max(8, min(grid_size, _CPU_DEMO_MAX_GRID)))
-    idx_coords = np.linspace(0, grid_size - 1, grid_size, dtype=np.float32)
-    Xi, Yi, Zi = np.meshgrid(idx_coords, idx_coords, idx_coords, indexing='ij')
-    geom_coords = np.linspace(0, 1, grid_size, dtype=np.float32)
-    Xg, Yg, Zg = np.meshgrid(geom_coords, geom_coords, geom_coords, indexing='ij')
-
-    if T <= 0:
-        target = 1.0
-    else:
-        target = float(T)
-    num_frames = min(30, max(2, int(min(target, 20)) + 1))
-    timeline = list(np.linspace(0.0, target, num_frames))
-    if len(timeline) < 2:
-        timeline.append(target)
-
-    vx = _safe_velocity_sample(vx_func)
-    vy = _safe_velocity_sample(vy_func)
-    vz = _safe_velocity_sample(vz_func)
-    drift_scale = 0.25 * grid_size
-
-    frames = []
-    for idx, t_val in enumerate(timeline):
-        phase_fraction = idx / (len(timeline) - 1) if len(timeline) > 1 else 0.0
-        drift = (
-            vx * phase_fraction * drift_scale,
-            vy * phase_fraction * drift_scale,
-            vz * phase_fraction * drift_scale,
-        )
-        field = _cpu_distribution_field(distribution_type, Xi, Yi, Zi, grid_size, drift, phase_fraction)
-        frames.append(field.astype(np.float32))
-        
-        if progress_callback:
-            percent = int(((idx + 1) / len(timeline)) * 100)
-            progress_callback(percent)
-
-    grid = pv.StructuredGrid()
-    grid.points = np.column_stack((Xg.ravel(), Yg.ravel(), Zg.ravel()))
-    grid.dimensions = [grid_size, grid_size, grid_size]
-    grid["scalars"] = frames[0].ravel()
-
-    times = [float(t) for t in timeline]
-    return frames, times, grid
-
-def get_geometry_figure():
-    """Generates a 3D Plotly figure for the selected geometry."""
-    geom = state.geometry_selection
-    
-    if geom == "Cube":
-        # Draw a unit cube
-        fig = _create_box_figure(1, 1, 1, "Cube")
-        
-    elif geom == "Rectangular domain with a heated box (3D)":
-        try:
-            L = float(state.domain_L)
-            W = float(state.domain_W)
-            H = float(state.domain_H)
-        except:
-            L, W, H = 1.0, 1.0, 1.0
-            
-        # Normalize so max dimension is 1
-        max_dim = max(L, W, H)
-        if max_dim > 0:
-            L /= max_dim
-            W /= max_dim
-            H /= max_dim
-            
-        fig = _create_box_figure(L, W, H, "Rectangular Domain")
-        
-    else:
-        # Empty figure
-        fig = go.Figure()
-        fig.update_layout(
-            scene=dict(xaxis=dict(visible=False), yaxis=dict(visible=False), zaxis=dict(visible=False)),
-            margin=dict(l=0, r=0, b=0, t=0),
-        )
-        return fig
-
-    fig.update_layout(
-        scene=dict(
-            xaxis=dict(visible=False),
-            yaxis=dict(visible=False),
-            zaxis=dict(visible=False),
-            aspectmode='data'
-        ),
-        margin=dict(l=0, r=0, b=0, t=30),
-    )
-    return fig
-
-def _create_box_figure(lx, ly, lz, title):
-    # Vertices
-    x = [0, lx, lx, 0, 0, lx, lx, 0]
-    y = [0, 0, ly, ly, 0, 0, ly, ly]
-    z = [0, 0, 0, 0, lz, lz, lz, lz]
-    
-    fig = go.Figure()
-    
-    # Solid Mesh (semi-transparent)
-    fig.add_trace(go.Mesh3d(
-        x=x, y=y, z=z,
-        # Indices for triangles (2 per face, 6 faces)
-        i = [7, 0, 0, 0, 4, 4, 6, 6, 4, 0, 3, 2],
-        j = [3, 4, 1, 2, 5, 6, 5, 2, 0, 1, 6, 3],
-        k = [0, 7, 2, 3, 6, 7, 1, 1, 5, 5, 7, 6],
-        opacity=0.2,
-        color='blue',
-        flatshading=True,
-        name=title,
-        showscale=False
-    ))
-    
-    # Wireframe Edges
-    # Define lines to connect vertices
-    xe = [0, lx, lx, 0, 0, None, 0, lx, lx, 0, 0, None, 0, 0, None, lx, lx, None, lx, lx, None, 0, 0]
-    ye = [0, 0, ly, ly, 0, None, 0, 0, ly, ly, 0, None, 0, 0, None, 0, 0, None, ly, ly, None, ly, ly]
-    ze = [0, 0, 0, 0, 0, None, lz, lz, lz, lz, lz, None, 0, lz, None, 0, lz, None, 0, lz, None, 0, lz]
-    
-    fig.add_trace(go.Scatter3d(
-        x=xe, y=ye, z=ze,
-        mode='lines',
-        line=dict(color='black', width=3),
-        showlegend=False
-    ))
-    
-    fig.update_layout(title=title)
-    return fig
-
-def update_geometry_view():
-    try:
-        fig = get_geometry_figure()
-        if hasattr(ctrl, "geometry_plot_update"):
-            ctrl.geometry_plot_update(fig)
-    except Exception as e:
-        print(f"Error updating geometry view: {e}")
-
-
-def export_simulation_vtk():
-    """Download the current simulation volume/isosurface as a VTK file."""
-    global current_grid_object
-
-    if not state.simulation_has_run or current_grid_object is None:
-        log_to_console("VTK export unavailable: run a simulation first.")
-        return
-
-    temp_path = None
-    try:
-        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
-        grid_size = int(state.grid_size or 0)
-        filename = f"qlbm_volume_n{grid_size}_{suffix}.vts"
-
-        tmp = tempfile.NamedTemporaryFile(suffix=".vts", delete=False)
-        tmp.close()
-        temp_path = Path(tmp.name)
-
-        current_grid_object.save(str(temp_path))
-        server.controller.download_file(temp_path.read_bytes(), filename)
-        log_to_console(f"Exported VTK to {filename}")
-    except Exception as exc:
-        log_to_console(f"VTK export failed: {exc}")
-    finally:
-        if temp_path and temp_path.exists():
-            try:
-                temp_path.unlink()
-            except Exception:
-                pass
-
-
-def export_simulation_mp4():
-    """Render the simulation frames to an MP4 animation for download."""
-    global simulation_data_frames, current_grid_object
-
-    if not state.simulation_has_run or not simulation_data_frames:
-        log_to_console("MP4 export unavailable: run a simulation first.")
-        return
-    if current_grid_object is None:
-        log_to_console("MP4 export failed: missing grid data.")
-        return
-
-    temp_path = None
-    movie_plotter = None
-    try:
-        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
-        grid_size = int(state.grid_size or 0)
-        filename = f"qlbm_animation_n{grid_size}_{suffix}.mp4"
-
-        tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-        tmp.close()
-        temp_path = Path(tmp.name)
-
-        movie_plotter = pv.Plotter(off_screen=True, window_size=(1280, 720))
-        try:
-            camera_position = plotter.camera_position if plotter.camera_position else None
-        except Exception:
-            camera_position = None
-
-        base_grid = current_grid_object.copy()
-        movie_plotter.open_movie(str(temp_path), framerate=15)
-
-        for frame_data in simulation_data_frames:
-            base_grid["scalars"] = np.asarray(frame_data).ravel()
-            iso_mesh = base_grid.contour(isosurfaces=7, scalars="scalars")
-            movie_plotter.clear()
-            movie_plotter.add_mesh(
-                iso_mesh,
-                cmap="Blues",
-                opacity=0.35,
-                show_scalar_bar=False,
-            )
-            movie_plotter.add_axes()
-            if camera_position:
-                try:
-                    movie_plotter.camera_position = camera_position
-                except Exception:
-                    pass
-            else:
-                movie_plotter.view_isometric()
-            movie_plotter.render()
-            movie_plotter.write_frame()
-
-        movie_plotter.close()
-        movie_plotter = None
-
-        server.controller.download_file(temp_path.read_bytes(), filename)
-        log_to_console(f"Exported MP4 to {filename}")
-    except Exception as exc:
-        log_to_console(f"MP4 export failed: {exc}")
-    finally:
-        if movie_plotter is not None:
-            try:
-                movie_plotter.close()
-            except Exception:
-                pass
-        if temp_path and temp_path.exists():
-            try:
-                temp_path.unlink()
-            except Exception:
-                pass
-
-def run_simulation():
-    global simulation_data_frames, simulation_times, current_grid_object
-    
-    if not _SIMULATION_CAN_RUN:
-        msg = _SIMULATION_DISABLED_REASON or "Simulation backend is not available on this platform."
-        state.run_error = msg
-        log_to_console(f"Error: {msg}")
-        state.status_message = "Error: Backend unavailable"
-        state.status_type = "error"
-        return
-
-    state.is_running = True
-    state.run_error = ""
-    state.simulation_has_run = False
-    state.show_progress = True
-    state.simulation_progress = 0
-    state.status_message = "Running simulation..."
-    state.status_type = "info"
-    
-    # Log initial configuration
-    config_lines = [
-        "Job Initiated",
-        f"  Grid Size: {state.grid_size} × {state.grid_size} × {state.grid_size}",
-        f"  Time Steps: {state.time_steps}",
-        f"  Distribution: {state.dist_type}",
-        f"  Boundary: {state.boundary_condition}",
-        f"  Backend: {state.selected_backend}",
-        f"  Velocity: vx={state.vx_expr}, vy={state.vy_expr}, vz={state.vz_expr}",
-    ]
-    for line in config_lines:
-        log_to_console(line)
-    
-    last_logged_percent = 0
-    def _progress_callback(percent):
-        nonlocal last_logged_percent
-        state.simulation_progress = percent
-        if percent - last_logged_percent >= 10:
-            log_to_console(f"Simulation progress: {int(percent)}%")
-            last_logged_percent = percent
-    
-    try:
-        # 1. Prepare Parameters
-        grid_size = int(state.grid_size)
-        num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
-        T = int(state.time_steps)
-        distribution_type = state.dist_type
-        boundary_condition = state.boundary_condition
-        
-        # Velocity functions
-        vx_func = make_velocity_func(state.vx_expr)
-        vy_func = make_velocity_func(state.vy_expr)
-        vz_func = make_velocity_func(state.vz_expr)
-        
-        # Update progress to indicate start
-        _progress_callback(0)
-        
-        if simulate_qlbm_3D_and_animate is not None:
-            # 2a. Run CUDA-Q Simulation
-            log_to_console("Running CUDA-Q Simulation...")
-            plotter.clear()
-            # Note: This call is blocking and doesn't report progress back to UI during execution
-            _, frames, times, grid_obj = simulate_qlbm_3D_and_animate(
-                num_reg_qubits=num_reg_qubits,
-                T=T,
-                distribution_type=distribution_type,
-                vx_input=vx_func,
-                vy_input=vy_func,
-                vz_input=vz_func,
-                boundary_condition=boundary_condition,
-                plotter=plotter,
-                add_slider=False,
-                progress_callback=_progress_callback
-            )
-        else:
-            # 2b. CPU Demo Simulation (approximate)
-            log_to_console("Running CPU Demo Simulation...")
-            frames, times, grid_obj = _run_cpu_demo_simulation(
-                grid_size=grid_size,
-                T=T,
-                distribution_type=distribution_type or "Sinusoidal",
-                vx_func=vx_func,
-                vy_func=vy_func,
-                vz_func=vz_func,
-                progress_callback=_progress_callback
-            )
-        
-        _progress_callback(100)
-        
-        # Force Blues colormap
-        if grid_obj:
-             plotter.clear()
-             isosurfaces = grid_obj.contour(isosurfaces=7, scalars="scalars")
-             plotter.add_mesh(isosurfaces, cmap="Blues", opacity=0.3, show_scalar_bar=True)
-             plotter.add_axes()
-             plotter.show_grid()
-        
-        # Remove the built-in slider widget from fluid3d_pyvista if present,
-        # as we are using the Trame UI slider.
-        # try:
-        #     plotter.clear_slider_widgets()
-        # except AttributeError:
-        #     pass
-        
-        # 3. Store Results
-        if frames and len(frames) > 0:
-            simulation_data_frames = frames
-            simulation_times = times
-            current_grid_object = grid_obj
-            
-            state.max_time_step = len(frames) - 1
-            state.time_val = 0
-            # Build formatted time labels for slider thumb (e.g., "0.0", "0.5", "1.0", ...)
-            state.time_slider_labels = [f"{t:.1f}" for t in times] if times else [str(i) for i in range(len(frames))]
-            state.simulation_has_run = True
-            
-            # The plotter is already updated by the function, but we ensure view update
-            # Enable picking
-            _ensure_point_picking(on_pick_point)
-            
-            ctrl.view_update()
-            log_to_console("Simulation completed successfully.")
-            state.status_message = "Simulation completed successfully."
-            state.status_type = "success"
-            state.simulation_progress = 100
-        else:
-            state.run_error = "Simulation produced no data."
-            log_to_console("Error: Simulation produced no data.")
-            state.status_message = "Error: No data produced"
-            state.status_type = "error"
-
-    except Exception as e:
-        state.run_error = f"Simulation failed: {str(e)}"
-        log_to_console(f"Simulation Error: {e}")
-        print(f"Simulation Error: {e}")
-        state.status_message = "Simulation failed"
-        state.status_type = "error"
-    finally:
-        state.is_running = False
-        # Keep progress visible for a moment or hide it? em_trame keeps it if we don't hide it.
-        # But usually we want to hide it after some time or keep it at 100%.
-        # For now, we leave show_progress=True so user sees 100%.
-        # But if we want to hide it on next run, we reset it at start.
-        if state.status_type == "success":
-             # Optional: Auto-hide after delay? Trame doesn't have easy setTimeout in python without async.
-             pass
-        else:
-             state.show_progress = False
-
-def stop_simulation():
-    state.is_running = False
-
-def reset_simulation():
-    state.is_running = False
-    state.run_error = ""
-    state.simulation_has_run = False
-    state.dist_type = None
-    state.show_edges = False
-    state.problems_selection = None
-    state.geometry_selection = None
-    state.backend_type = None
-    state.advecting_field = None
-    state.show_advect_params = False
-    plotter.clear()
-    ctrl.view_update()
-    _apply_workflow_highlights(_determine_workflow_step())
-
-# --- Handlers ---
-
-@state.change("advecting_field")
-def _on_advect_dropdown_change(advecting_field, **_):
-    if advecting_field:
-        set_velocity_preset(advecting_field)
-    _apply_workflow_highlights(_determine_workflow_step())
-
-@state.change("grid_index")
-def _on_grid_index_change(grid_index, **_):
-    """Map discrete slider index to allowed grid sizes [8,16,32,64,128,256]."""
-    try:
-        allowed = [8, 16, 32, 64, 128, 256]
-        if grid_index is None:
-            return
-        if isinstance(grid_index, (int, float)):
-            idx = int(grid_index)
-            idx = max(0, min(idx, len(allowed) - 1))
-            val = allowed[idx]
-            
-            # Update grid_size state
-            if state.grid_size != val:
-                state.grid_size = val
-                # Also update the qubit plot
-                fig, info, warn = update_qubit_3D_info(val)
-                state.qubit_grid_info = info
-                state.qubit_warning = warn
-                if hasattr(ctrl, "qubit_plot_update"):
-                    ctrl.qubit_plot_update(fig)
-            
-            # Update nx state and view (replacing on_grid_change logic)
-            if state.nx != val:
-                state.nx = val
-                state.gauss_cx = val / 2
-                state.gauss_cy = val / 2
-                state.gauss_cz = val / 2
-                state.show_edges = True  # Enable edges when user interacts with slider
-                update_view()
-
-    except Exception:
-        pass
-    finally:
-        _apply_workflow_highlights(_determine_workflow_step())
-
-@state.change("problems_selection")
-def _on_problem_selection_change(problems_selection, **_):
-    """Auto-select geometry based on the chosen problem and show read-only."""
-    try:
-        if not problems_selection:
-            state.geometry_selection = None
-            return
-
-        if isinstance(problems_selection, str):
-            normalized = problems_selection.strip()
-            state.geometry_selection = _PROBLEM_GEOMETRY_MAP.get(normalized)
-        else:
-            state.geometry_selection = None
-    except Exception:
-        state.geometry_selection = None
-    finally:
-        _apply_workflow_highlights(_determine_workflow_step())
-
-@state.change("dist_type")
-def _on_dist_type_change(dist_type, **_):
-    # Whenever the user picks a new excitation, hide edges until they touch the slider again
-    if state.show_edges:
-        state.show_edges = False
-    update_view()
-    _apply_workflow_highlights(_determine_workflow_step())
-
-
-@state.change("show_edges", "sine_k_x", "sine_k_y", "sine_k_z", "gauss_cx", "gauss_cy", "gauss_cz", "gauss_sigma")
-def on_param_change(**kwargs):
-    update_view()
-    _apply_workflow_highlights(_determine_workflow_step())
-
-
-@state.change("geometry_selection", "domain_L", "domain_W", "domain_H")
-def _on_geometry_selection_change(**_):
-    update_geometry_view()
-    _apply_workflow_highlights(_determine_workflow_step())
-
-
-@state.change("backend_type")
-def _on_backend_type_change(**_):
-    _apply_workflow_highlights(_determine_workflow_step())
-
-
-@state.change("time_val")
-def update_time_frame(time_val, **_):
-    """Update the plotter with the frame corresponding to time_val."""
-    global simulation_data_frames, simulation_times, current_grid_object
-    
-    if not state.simulation_has_run or not simulation_data_frames or current_grid_object is None:
-        return
-        
-    try:
-        idx = int(time_val)
-        if 0 <= idx < len(simulation_data_frames):
-            # Update grid scalars
-            current_grid_object["scalars"] = simulation_data_frames[idx].flatten()
-            
-            # Re-compute isosurfaces
-            # Note: contour() returns a new mesh. We need to replace the actor.
-            isosurfaces = current_grid_object.contour(isosurfaces=7, scalars="scalars")
-            
-            plotter.clear()
-            plotter.add_mesh(isosurfaces, cmap="Blues", opacity=0.3, show_scalar_bar=True)
-            plotter.add_axes()
-            plotter.show_grid()
-            
-            # Update time label (use actual time from simulation_times)
-            t_val = simulation_times[idx] if idx < len(simulation_times) else idx
-            state.current_time_label = f"{t_val:.2f}" if isinstance(t_val, float) else str(t_val)
-            plotter.add_text(f"Time: {t_val:.2f}" if isinstance(t_val, float) else f"Time: {t_val}", name="time_label", position="upper_right")
-            
-            # Enable picking
-            _ensure_point_picking(on_pick_point)
-            
-            ctrl.view_update()
-    except Exception as e:
-        print(f"Error updating time frame: {e}")
-
-# --- UI Layout ---
-
-with SinglePageLayout(server) as layout:
-    layout.title.set_text("")
-    layout.toolbar.hide = True
-    
-    html.Style("""
-    :root{ --v-theme-primary:95,37,159; }
-    .example-img{ max-width:100%; border-radius:4px; }
-    .warn-text{ color:#b71c1c; font-size:0.85rem; }
-    """)
-    
-    with layout.content:
-        with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-            with vuetify3.VRow(no_gutters=True, classes="fill-height"):
-                
-                # --- Left Column: Controls ---
-                with vuetify3.VCol(cols=5, classes="pa-2 d-flex flex-column" , style="overflow-y: auto; max-height: 200vh;"):
-                    # Overview cell (from qlbm)
-                    with vuetify3.VCard(classes="mb-2", style=("overview_card_style", "font-size: 0.8rem;")):
-                        vuetify3.VCardTitle("Overview", classes="text-subtitle-2 font-weight-bold text-primary")
-                        with vuetify3.VCardText():
-                            vuetify3.VDivider(classes="my-2")
-                            vuetify3.VCardSubtitle("Problems", classes="text-caption font-weight-bold mt-2")
-                            vuetify3.VSelect(
-                                key="overview_problems",
-                                label="Select a problem",
-                                v_model=("problems_selection", None),
-                                items=(
-                                    "qlbm_problems",
-                                    [
-                                        "Scalar advection-diffusion in a box",
-                                        "Laminar flow & heat transfer for a heated body in water.",
-                                    ],
-                                ),
-                                placeholder="Select",
-                                density="compact",
-                                hide_details=True,
-                                color="primary",
-                                classes="mb-2"
-                            )
-                            vuetify3.VCardSubtitle("Governing Equations", classes="text-caption font-weight-bold mt-2")
-                            vuetify3.VListItemTitle("Laminar Navier-Stokes including energy", classes="text-caption")
-                            vuetify3.VCardSubtitle("Inputs", classes="text-caption font-weight-bold mt-2")
-                            vuetify3.VListItemTitle("Geometry, Boundary conditions - temperature and flow", classes="text-caption")
-                            vuetify3.VCardSubtitle("Outputs", classes="text-caption font-weight-bold mt-2")
-                            vuetify3.VListItemTitle("Surface plots on sections OR sampling through a line in 3D domain", classes="text-caption")
-
-                    # Geometry cell
-                    with vuetify3.VCard(classes="mb-2"):
-                        vuetify3.VCardTitle("Geometry", classes="text-subtitle-2 font-weight-bold text-primary")
-                        with vuetify3.VCardText():
-                            # Read-only geometry display auto-set by problem selection
-                            vuetify3.VAlert(
-                                v_if="geometry_selection",
-                                type="info",
-                                variant="tonal",
-                                density="compact",
-                                color="primary",
-                                children=["Selected Geometry: ", "{{ geometry_selection }}"],
-                                classes="mb-2"
-                            )
-                            vuetify3.VAlert(
-                                v_if="!geometry_selection",
-                                type="info",
-                                variant="tonal",
-                                density="compact",
-                                color="primary",
-                                children=["No geometry selected. Choose a problem to auto-set."],
-                                classes="mb-2"
-                            )
-                            with vuetify3.VContainer(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="pa-0 mt-2"):
-                                vuetify3.VCardSubtitle("Domain dimensions", classes="text-caption font-weight-bold mb-2")
-                                with vuetify3.VRow(dense=True):
-                                    # Length
-                                    with vuetify3.VCol():
-                                        with vuetify3.VTooltip(location="top"):
-                                            with vuetify3.Template(v_slot_activator="{ props }"):
-                                                vuetify3.VTextField(label="Length (L)", v_model=("domain_L", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary", v_bind="props")
-                                            html.Span("Relative Length. The domain is scaled so the largest dimension is 1.0.")
-                                    # Width
-                                    with vuetify3.VCol():
-                                        with vuetify3.VTooltip(location="top"):
-                                            with vuetify3.Template(v_slot_activator="{ props }"):
-                                                vuetify3.VTextField(label="Width (W)", v_model=("domain_W", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary", v_bind="props")
-                                            html.Span("Relative Width. The domain is scaled so the largest dimension is 1.0.")
-                                    # Height
-                                    with vuetify3.VCol():
-                                        with vuetify3.VTooltip(location="top"):
-                                            with vuetify3.Template(v_slot_activator="{ props }"):
-                                                vuetify3.VTextField(label="Height (H)", v_model=("domain_H", 1.0), type="number", step="0.1", density="compact", hide_details=True, color="primary", v_bind="props")
-                                            html.Span("Relative Height. The domain is scaled so the largest dimension is 1.0.")
-
-                    with vuetify3.VCard(classes="mb-2", style=("distribution_card_style", "font-size: 0.8rem;")):
-                        with vuetify3.VCardTitle("Initial Distribution", classes="text-subtitle-2 font-weight-bold text-primary"): pass
-                        with vuetify3.VCardText():
-                            
-                            # Row with Select + Customize Button
-                            with vuetify3.VRow(classes="d-flex align-center mb-2", no_gutters=True):
-                                with vuetify3.VCol(cols="auto", classes="flex-grow-1"):
-                                    
-                                    # TOOLTIP FOR DROPDOWN
-                                    with vuetify3.VTooltip(location="top"):
-                                        with vuetify3.Template(v_slot_activator="{ props }"):
-                                            vuetify3.VSelect(
-                                                label="Initial Distribution",
-                                                v_model=("dist_type", None),
-                                                items=("dist_modes",), 
-                                                density="compact",
-                                                hide_details=True,
-                                                v_bind="props"
-                                            )
-                                        # FIXED: Using html.Span instead of vuetify3.Span
-                                        html.Span("Select the mathematical function used to initialize the field.")
-
-                                with vuetify3.VCol(cols="auto", classes="ml-2"):
-                                    
-                                    # TOOLTIP FOR CUSTOMIZE BUTTON
-                                    with vuetify3.VTooltip(location="top"):
-                                        with vuetify3.Template(v_slot_activator="{ props }"):
-                                            with vuetify3.VBtn(
-                                                icon=True, density="compact", variant="text",
-                                                click="custom_dist_params = !custom_dist_params",
-                                                v_bind="props"
-                                            ):
-                                                vuetify3.VIcon("mdi-cog", color=("custom_dist_params ? 'primary' : 'grey'",))
-                                        html.Span("Toggle advanced parameters (Frequency / Position / Width).")
-
-                    # --- Conditional Controls ---
-                    
-                    # 1. SINUSOIDAL CONTROLS
-                    with vuetify3.VCard(classes="mb-2", v_if="custom_dist_params && dist_type === 'Sinusoidal'"):
-                        with vuetify3.VCardTitle("Sinusoidal Frequencies"): pass
-                        with vuetify3.VCardText():
-                            for axis in ['x', 'y', 'z']:
-                                with vuetify3.VTooltip(location="start"):
-                                    with vuetify3.Template(v_slot_activator="{ props }"):
-                                        vuetify3.VSlider(
-                                            label=f"Freq {axis.upper()}", 
-                                            v_model=(f"sine_k_{axis}", 1.0), 
-                                            min=1, max=5, step=1, 
-                                            thumb_label="always", density="compact",
-                                            v_bind="props"
-                                        )
-                                    html.Span(f"Number of full wave cycles along the {axis.upper()} axis. Must be an integer to maintain periodic boundaries.")
-
-                    # 2. GAUSSIAN CONTROLS
-                    with vuetify3.VCard(classes="mb-2", v_if="custom_dist_params && dist_type === 'Gaussian'"):
-                        with vuetify3.VCardTitle("Gaussian Parameters"): pass
-                        with vuetify3.VCardText():
-                            # Centers
-                            for axis in ['x', 'y', 'z']:
-                                with vuetify3.VTooltip(location="start"):
-                                    with vuetify3.Template(v_slot_activator="{ props }"):
-                                        vuetify3.VSlider(
-                                            label=f"Center {axis.upper()}", 
-                                            v_model=(f"gauss_c{axis}", 16), 
-                                            min=0, max=("nx", 32), step=1, 
-                                            thumb_label="always", density="compact",
-                                            v_bind="props"
-                                        )
-                                    html.Span(f"Shift the center (Mean) of the blob along the {axis.upper()} axis.")
-                            
-                            # Width
-                            with vuetify3.VTooltip(location="start"):
-                                with vuetify3.Template(v_slot_activator="{ props }"):
-                                    vuetify3.VSlider(
-                                        label="Width (Sigma)", 
-                                        v_model=("gauss_sigma", 6.0), 
-                                        min=1.0, max=20.0, step=0.5, 
-                                        thumb_label="always", density="compact",
-                                        v_bind="props"
-                                    )
-                                html.Span("Controls the spread (Standard Deviation). Higher Sigma = wider, fuzzier blob.")
-
-                    # Boundary Conditions
-                    with vuetify3.VCard(classes="mb-2"):
-                        vuetify3.VCardTitle("Boundary Conditions", classes="text-subtitle-2 font-weight-bold text-primary")
-                        with vuetify3.VCardText():
-                            vuetify3.VSelect(label="Boundary Condition", v_model=("boundary_condition", "Periodic"), items=("['Periodic']",), density="compact", hide_details=True, color="primary")
-
-                    # Advecting Fields
-                    with vuetify3.VCard(classes="mb-2", style=("advect_card_style", "font-size: 0.8rem;")):
-                        vuetify3.VCardTitle("Advecting Fields", classes="text-subtitle-2 font-weight-bold text-primary")
-                        with vuetify3.VCardText():
-                            with vuetify3.VRow(classes="d-flex align-center mb-2", no_gutters=True):
-                                with vuetify3.VCol(cols="auto", classes="flex-grow-1"):
-                                    vuetify3.VSelect(
-                                        label="Select Advecting field",
-                                        v_model=("advecting_field", None),
-                                        items=("['Uniform', 'Swirl', 'Shear', 'TGV']",),
-                                        density="compact",
-                                        hide_details=True,
-                                        color="primary",
-                                        placeholder="Select",
-                                    )
-                                with vuetify3.VCol(cols="auto", classes="ml-2"):
-                                    with vuetify3.VTooltip(location="top"):
-                                        with vuetify3.Template(v_slot_activator="{ props }"):
-                                            with vuetify3.VBtn(
-                                                icon=True,
-                                                density="compact",
-                                                variant="text",
-                                                click="show_advect_params = !show_advect_params",
-                                                v_bind="props",
-                                            ):
-                                                vuetify3.VIcon("mdi-cog", color=("show_advect_params ? 'primary' : 'grey'",))
-                                        html.Span("Toggle velocity component inputs.")
-                            with vuetify3.VContainer(v_if="show_advect_params", classes="pa-0 mt-2"):
-                                html.Div("Velocity Components", classes="text-caption mb-1")
-                                vuetify3.VTextField(label="Velocity vx", v_model=("vx_expr", "0.2"), density="compact", hide_details=True, color="primary", classes="mb-1")
-                                vuetify3.VTextField(label="Velocity vy", v_model=("vy_expr", "-0.15"), density="compact", hide_details=True, color="primary", classes="mb-1")
-                                vuetify3.VTextField(label="Velocity vz", v_model=("vz_expr", "0.3"), density="compact", hide_details=True, color="primary")
-
-                    # Meshing
-                    with vuetify3.VCard(classes="mb-2", style=("meshing_card_style", "font-size: 0.8rem;")):
-                        vuetify3.VCardTitle("Meshing", classes="text-subtitle-2 font-weight-bold 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",
-                                        label="Number of Points / Direction",
-                                        v_model=("grid_index", 2),
-                                        min=0, max=5, step=1,
-                                        thumb_label="always",
-                                        show_ticks="always",
-                                        color="primary",
-                                        density="compact",
-                                        hide_details=True
-                                    ):
-                                        vuetify3.Template(v_slot_thumb_label="{ modelValue }", children=["{{ ['8','16','32','64','128','256'][modelValue] }}"])
-                                with vuetify3.VSheet(classes="pa-2", elevation=6, rounded=True, style="width: 700px;"):
-                                    with vuetify3.VContainer(fluid=True, classes="pa-0"):
-                                        qubit_fig = plotly_widgets.Figure(figure=go.Figure(), style="width: 616px; height: 320px; min-height: 320px;", responsive=True)
-                                        ctrl.qubit_plot_update = qubit_fig.update
-                                        html.Div("{{ qubit_grid_info }}", classes="mt-2 text-caption")
-                                        html.Div("{{ qubit_warning }}", classes="warn-text")
-                                        vuetify3.VAlert(v_if="grid_size > 32", type="warning", variant="tonal", density="compact", children=["Warning: High grid size may impact performance."], classes="mt-2")
-
-                    # Time
-                    with vuetify3.VCard(classes="mb-2"):
-                        vuetify3.VCardTitle("Time", classes="text-subtitle-2 font-weight-bold text-primary")
-                        with vuetify3.VCardText():
-                            vuetify3.VSlider(label="Total Time", v_model=("time_steps", 10), min=0, max=2000, step=10, thumb_label="always", show_ticks="always", color="primary", density="compact", hide_details=True)
-                            vuetify3.VAlert(v_if="time_steps > 100", type="warning", variant="tonal", density="compact", children=["Warning: High time steps may increase runtime."], classes="mt-2")
-
-                    # Backends
-                    with vuetify3.VCard(classes="mb-2", style=("backend_card_style", "font-size: 0.8rem;")):
-                        vuetify3.VCardTitle("Backends", classes="text-subtitle-2 font-weight-bold 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'")
-                                    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'")
-                            vuetify3.VDivider(classes="my-3")
-                            vuetify3.VBtn(
-                                text="Run",
-                                color="primary",
-                                block=True,
-                                disabled=("is_running || !simulation_backend_ready", False),
-                                click=run_simulation,
-                                style=("is_running ? '' : 'background-color:#87CEFA;'", ""),
-                            )
-                            html.Div("Backend: {{ simulation_backend_mode }}", classes="text-caption text-medium-emphasis mt-2")
-                            vuetify3.VAlert(
-                                v_if="simulation_backend_note",
-                                type="info",
-                                variant="tonal",
-                                density="compact",
-                                children=["{{ simulation_backend_note }}"],
-                                classes="mt-2",
-                            )
-                            with vuetify3.VRow(dense=True, classes="mt-2"):
-                                with vuetify3.VCol(cols=6):
-                                    vuetify3.VBtn(
-                                        text="Reset",
-                                        color="#8BC34A",
-                                        variant="tonal",
-                                        block=True,
-                                        disabled=("is_running", False),
-                                        click=reset_simulation,
-                                    )
-                                with vuetify3.VCol(cols=6):
-                                    vuetify3.VBtn(
-                                        text="STOP",
-                                        color="#FF7043",
-                                        variant="tonal",
-                                        block=True,
-                                        click=stop_simulation,
-                                        disabled=("!is_running", True),
-                                    )
-
-                # --- Right Column: Plotter ---
-                with vuetify3.VCol(cols=7, classes="pa-1 d-flex flex-column"):
-                    # Main Plot Card
-                    with vuetify3.VCard(classes="mb-1 flex-grow-1 d-flex flex-column", elevation=2, style="min-height: 0;"):
-                         
-                         # 0. Geometry Preview (Plotly) - Show when NOT simulation_has_run AND NO dist_type AND geometry_selection
-                         with vuetify3.VContainer(v_if="!simulation_has_run && !dist_type && geometry_selection", fluid=True, classes="pa-0 flex-grow-1", style="width: 100%; height: 100%;"):
-                            geom_fig = plotly_widgets.Figure(figure=go.Figure(), style="width: 100%; height: 100%;", responsive=True)
-                            ctrl.geometry_plot_update = geom_fig.update
-
-                         # 1. Preview (Plotly) - Show when NOT simulation_has_run AND dist_type is selected
-                         with vuetify3.VContainer(v_if="!simulation_has_run && dist_type", fluid=True, classes="pa-0 flex-grow-1", style="width: 100%; height: 100%;"):
-                            preview_fig = plotly_widgets.Figure(figure=go.Figure(), style="width:100%; height:100%;", responsive=True)
-                            ctrl.preview_update = preview_fig.update
-
-                         # Download controls (shown once simulation data exists)
-                         with vuetify3.VContainer(v_if="simulation_has_run", classes="px-4 pt-3 pb-1 d-flex justify-end", style="width: 100%; flex: 0 0 auto;"):
-                             with vuetify3.VMenu(location="bottom end"):
-                                 with vuetify3.Template(v_slot_activator="{ props }"):
-                                     vuetify3.VBtn(
-                                         v_bind="props",
-                                         text="Download",
-                                         color="primary",
-                                         variant="tonal",
-                                         prepend_icon="mdi-download"
-                                     )
-                                 with vuetify3.VList(density="compact"):
-                                     vuetify3.VListItem(
-                                         title="Export as VTK",
-                                         prepend_icon="mdi-content-save",
-                                         click=export_simulation_vtk
-                                     )
-                                     vuetify3.VListItem(
-                                         title="Export as MP4",
-                                         prepend_icon="mdi-movie",
-                                         click=export_simulation_mp4
-                                     )
-
-                         # 2. Simulation Result (PyVista) - Show when simulation_has_run
-                         with vuetify3.VContainer(v_if="simulation_has_run", fluid=True, classes="pa-0 flex-grow-1", style="width: 100%; height: 100%;"):
-                            view = plotter_ui(plotter)
-                            ctrl.view_update = view.update
-                         
-                         # Time Slider (visible only after simulation run)
-                         with vuetify3.VContainer(v_if="simulation_has_run", classes="px-4 pb-4", style="width: 90%; flex: 0 0 auto;"):
-                             with vuetify3.VSlider(
-                                 v_model=("time_val", 0),
-                                 min=0,
-                                 max=("max_time_step", 10),
-                                 step=1,
-                                 label="Time",
-                                 thumb_label="always",
-                                 density="compact",
-                                 hide_details=True,
-                                 color="primary"
-                             ):
-                                 vuetify3.Template(
-                                     v_slot_thumb_label="{ modelValue }",
-                                     children=["{{ time_slider_labels[modelValue] || modelValue }}"]
-                                 )
-
-                    # Console Window (In-column)
-                    with vuetify3.VCard(classes="mt-1", style="font-size: 0.8rem; flex: 0 0 auto;"):
-                        with vuetify3.VCardTitle("Status", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
-                            pass
-                        with vuetify3.VCardText(classes="py-1 px-2", style="height: 150px; overflow-y: auto; background-color: #f5f5f5; font-family: monospace;"):
-                            vuetify3.VTextarea(
-                                v_model=("console_output", ""),
-                                readonly=True,
-                                auto_grow=False,
-                                rows=6,
-                                variant="plain",
-                                hide_details=True,
-                                style="font-family: monospace; width: 100%; height: 100%;"
-                            )
-
-        # Status Window - Fixed at bottom right (Floating, for progress)
-        with vuetify3.VCard(
-            v_if="status_visible",
-            style="position: fixed; bottom: 16px; right: 16px; z-index: 1000; min-width: 320px; max-width: 450px;",
-            elevation=8
-        ):
-            with vuetify3.VCardTitle(classes="d-flex align-center", style="font-size: 0.95rem; padding: 8px 12px;"):
-                vuetify3.VIcon("mdi-information-outline", size="small", classes="mr-2")
-                html.Span("Simulation Status")
-                vuetify3.VSpacer()
-                vuetify3.VBtn(
-                    icon="mdi-close",
-                    size="x-small",
-                    variant="text",
-                    click="status_visible = false"
-                )
-            vuetify3.VDivider()
-            with vuetify3.VCardText(classes="py-2 px-3"):
-                # Status message
-                vuetify3.VAlert(
-                    type=("status_type", "info"),
-                    variant="tonal",
-                    density="compact",
-                    children=["{{ status_message }}"]
-                )
-                # Progress bar (shown when simulation is running)
-                with vuetify3.VContainer(v_if="show_progress", classes="pa-0 mt-2"):
-                    vuetify3.VProgressLinear(
-                        model_value=("simulation_progress", 0),
-                        color="primary",
-                        height=6,
-                        striped=True
-                    )
-                    html.Div(
-                        "{{ simulation_progress }}% complete",
-                        classes="text-caption text-center mt-1",
-                        style="font-size: 0.75rem;"
-                    )
-
-# --- Entry point ---
-if __name__ == "__main__":
-    import argparse
-    import errno
-    import os
-
-    update_view()
-
-    parser = argparse.ArgumentParser(description="Start 3D Isosurface Explorer Trame server")
-    parser.add_argument("--host", default=None, help="Host/IP to bind (default: 127.0.0.1 locally; 0.0.0.0 if PORT/HF_PORT set)")
-    parser.add_argument("--port", type=int, default=None, help="Port to bind (default: TRIAL_APP_PORT or 8702 locally)")
-    args = parser.parse_args()
-
-    env_port = os.environ.get("PORT") or os.environ.get("HF_PORT")
-    # If platform provides a port (e.g., Hugging Face Spaces), bind exactly there with 0.0.0.0 and do not auto-fallback.
-    if env_port:
-        host = args.host or "0.0.0.0"
-        port = int(env_port)
-        server.start(host=host, port=port, open_browser=False)
-    else:
-        # Local dev: allow CLI/env override and auto-increment to find a free port if busy.
-        base_port = args.port or int(os.environ.get("TRIAL_APP_PORT", "8702"))
-        host = args.host or os.environ.get("TRIAL_HOST", "127.0.0.1")
-        max_tries = 20
-        last_err = None
-        for i in range(max_tries):
-            try:
-                port = base_port + i
-                server.start(host=host, port=port, open_browser=False)
-                break
-            except OSError as e:
-                last_err = e
-                # EADDRINUSE -> try next
-                if getattr(e, 'errno', None) in (errno.EADDRINUSE, 98):
-                    continue
-                # Other bind errors -> raise immediately
-                raise
-        else:
-            raise RuntimeError(f"Failed to bind after {max_tries} attempts starting at port {base_port}: {last_err}")

qlbm_trame.py

@@ -1,12 +0,0 @@
-import os
-import sys
-
-# Configure VTK for headless rendering BEFORE any VTK imports
-if os.environ.get("PORT") or os.environ.get("HF_PORT") or os.environ.get("SPACE_ID"):
-    os.environ["MESA_GL_VERSION_OVERRIDE"] = "3.2"
-    os.environ["MESA_GLSL_VERSION_OVERRIDE"] = "150"
-    os.environ["GALLIUM_DRIVER"] = "llvmpipe"
-    # Force VTK to use OSMesa for offscreen rendering
-    os.environ["VTK_DEFAULT_EGL_DEVICE_INDEX"] = "-1"
-
-# ...existing imports...

utils/fdtd_demo.ipynb

@@ -1,326 +0,0 @@
-{
- "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/fdtd_grid16by16_time1_dt0.1_ancilla1_offset0_fieldEz_x8_y8_adapt_aqc 1.qasm

@@ -1,553 +0,0 @@
-OPENQASM 3.0;
-include "stdgates.inc";
-qubit[10] system;
-qubit[1] ancilla;
-qubit[1] Naimark;
-rx(-0.009929826774008) system[0];
-ry(0.004724135008185915) system[2];
-rx(-0.0686202769901092) system[4];
-ry(0.0029229585023471394) system[5];
-rz(-2.1854592787170617) system[7];
-cx system[0], system[9];
-ry(0.027400034915722626) system[0];
-cx system[0], system[1];
-rz(-0.7463947655035743) system[0];
-rx(0.02042320381868934) system[0];
-cx system[0], system[9];
-rz(-1.8230334240531008) system[0];
-ry(-0.027350205506260217) system[0];
-cx system[0], system[8];
-rz(2.5671372108276835) system[0];
-ry(0.039786737396934946) system[0];
-ry(0.007676353616585585) system[1];
-ry(-0.001805718052178884) system[9];
-cx system[4], Naimark[0];
-ry(0.0057912581312564715) Naimark[0];
-rz(2.9347571909778827) system[4];
-ry(-0.012528680630899736) system[4];
-cx system[4], system[5];
-rz(0.4859678147514519) system[4];
-ry(-0.012019499696038105) system[4];
-cx system[0], system[4];
-rz(0.5693250047567826) system[0];
-rx(-0.0309915671580967) system[0];
-cx system[0], Naimark[0];
-ry(-0.004061605248347311) Naimark[0];
-rz(0.20054303336987656) system[0];
-rx(-0.0654168174177241) system[0];
-cx system[0], system[9];
-rz(0.88253193990888) system[0];
-ry(0.040010415867415716) system[0];
-ry(0.00799719255391218) system[4];
-cx system[0], system[4];
-rz(3.1172080946137664) system[0];
-rx(0.05797126294265653) system[0];
-ry(0.0033198555528590745) system[4];
-ry(0.021232804271263506) system[4];
-rz(-0.25852474968713945) system[5];
-cx system[0], system[5];
-rz(0.3196851116661861) system[0];
-ry(0.03318974506177552) system[0];
-rz(-3.1288178532632527) system[5];
-ry(0.018811277080629907) system[5];
-cx system[5], system[6];
-rz(0.5377005190620405) system[5];
-rx(0.019763079252683946) system[5];
-ry(-0.0037382199378650505) system[9];
-cx system[0], system[9];
-rz(-2.4486180001926314) system[0];
-ry(0.06063543646138503) system[0];
-cx system[0], system[8];
-rz(-2.774363599584902) system[0];
-rx(-0.0206401099975011) system[0];
-cx system[0], system[1];
-rz(-0.3187491632873889) system[0];
-ry(-0.03589693966842655) system[0];
-rx(0.0037864611143736404) system[1];
-ry(-0.03539478262076856) system[1];
-rz(3.09594607920261) system[8];
-cx system[5], system[8];
-rz(0.6657455137535487) system[5];
-ry(-0.025849856763279222) system[5];
-rz(3.059875645069256) system[8];
-ry(0.029113654640829045) system[8];
-cx system[8], Naimark[0];
-ry(0.0101221689454849) Naimark[0];
-rz(0.018068722269390713) system[8];
-rx(0.025345162645482144) system[8];
-rx(-0.0011829648386165736) system[9];
-cx system[0], system[9];
-rz(1.3781527904622721) system[0];
-ry(-0.028711392721448403) system[0];
-cx system[0], system[4];
-rz(-0.11143542611262425) system[0];
-rx(-0.05603774712094567) system[0];
-rx(0.0010447338966630415) system[4];
-ry(-0.04479042313876458) system[4];
-cx system[4], Naimark[0];
-rz(-3.0844929025229275) Naimark[0];
-rz(-0.08255572981249815) system[4];
-ry(0.023804914814244738) system[4];
-rz(3.103546440492554) system[9];
-rz(2.7799319025884284) system[9];
-cx system[1], system[9];
-rz(-1.2883775125138963) system[1];
-ry(0.01822672749196208) system[1];
-cx system[1], Naimark[0];
-ry(0.009377744466731341) Naimark[0];
-ry(0.03179438408982582) Naimark[0];
-rz(0.33903485027948355) system[1];
-rx(0.043572158586145715) system[1];
-rz(2.9623962882808392) system[9];
-ry(0.0027440497246247197) system[9];
-cx system[8], system[9];
-rz(-0.6592370478820975) system[8];
-ry(-0.013271281403817392) system[8];
-cx system[4], system[8];
-ry(-0.02070698518802172) system[4];
-rz(-0.007670035645202189) system[4];
-rz(0.06496056026088182) system[8];
-ry(0.009329273119684345) system[8];
-cx system[0], system[8];
-rz(2.4880621327793584) system[0];
-rx(0.04481168580667649) system[0];
-ry(0.0013522036871222998) system[8];
-cx system[1], system[8];
-rz(0.0031448285399942044) system[1];
-ry(-0.010972742328514418) system[1];
-ry(0.012713967945394034) system[8];
-rx(-0.0039036910533283287) system[9];
-cx system[5], system[9];
-rz(0.7599795586518138) system[5];
-rx(-0.01608254297217182) system[5];
-cx system[5], system[6];
-rz(-0.5690509388859626) system[5];
-rx(-0.0017186276266858425) system[5];
-ry(-0.0020154056388657082) system[6];
-ry(0.012944280233578853) system[9];
-cx system[0], system[9];
-rz(0.16644237678417806) system[0];
-rx(0.047793563158643915) system[0];
-cx system[0], Naimark[0];
-ry(-0.030252812233535264) Naimark[0];
-rz(1.0747300496502332) system[0];
-ry(-0.05803895137493731) system[0];
-cx system[0], system[8];
-rz(-0.6262596737268766) system[0];
-rx(0.08712099324802214) system[0];
-cx system[0], system[1];
-rz(-0.6605360455225995) system[0];
-ry(-0.06147490007082812) system[0];
-ry(0.01281991274398031) system[1];
-rx(0.039844381573964416) system[1];
-ry(0.007638305504808374) system[8];
-rx(0.002803525410413066) system[8];
-ry(-0.0075099151033604095) system[9];
-ry(0.038341771256415136) system[9];
-cx system[1], system[9];
-rz(0.2513196725730653) system[1];
-rx(-0.09285400642538222) system[1];
-cx system[1], Naimark[0];
-rz(2.9678621472280016) Naimark[0];
-ry(0.006650622157603037) Naimark[0];
-rz(0.51983357989024) system[1];
-rx(0.036377523310496596) system[1];
-cx system[1], system[4];
-rz(-0.4187039274666453) system[1];
-ry(-0.03848288516583609) system[1];
-cx system[1], system[5];
-rz(2.686071905243066) system[1];
-rx(-0.05880384911951242) system[1];
-ry(0.020979733647543464) system[4];
-rx(-0.025601507276202584) system[4];
-ry(-0.00856253456519851) system[5];
-ry(-0.049286631253192104) system[9];
-cx system[4], system[9];
-rz(-0.5820865977218292) system[4];
-ry(-0.03725764097066575) system[4];
-rz(3.085511090235535) system[9];
-rx(0.03160455813525376) system[9];
-cx system[9], Naimark[0];
-cx system[1], Naimark[0];
-ry(-0.0018817320591488773) Naimark[0];
-ry(-0.0027210076906778458) Naimark[0];
-rz(2.7470896394107465) system[1];
-ry(0.04709223295866849) system[1];
-cx system[1], system[8];
-rz(0.6216830491259504) system[1];
-ry(0.004110733310723758) system[1];
-cx system[0], system[1];
-rz(-0.2892381135035573) system[0];
-ry(0.05645238747821191) system[0];
-rx(-0.0013960436853235336) system[1];
-rx(0.04081528878589302) system[1];
-cx system[4], Naimark[0];
-ry(-0.10551914519200922) Naimark[0];
-rz(0.12857028301657714) system[4];
-rx(-0.04399271417926798) system[4];
-ry(-0.03878890504120425) system[8];
-rx(-0.0015147246189397556) system[8];
-cx system[4], system[8];
-rz(0.07241238464453548) system[4];
-ry(0.03669256854019509) system[4];
-ry(-0.01770081312317262) system[8];
-rz(0.12459413032775957) system[8];
-rz(-0.2653529309684237) system[9];
-rx(-0.0013686267420343068) system[9];
-cx system[1], system[9];
-rz(0.5063195889939947) system[1];
-rx(0.10222195125830269) system[1];
-cx system[1], system[5];
-rz(-0.7977244858244403) system[1];
-ry(-0.046322495855074086) system[1];
-cx system[1], system[8];
-rz(-0.10869711872819798) system[1];
-ry(-0.09101808478741935) system[1];
-ry(0.004836890553977735) system[5];
-ry(0.00970972689547378) system[5];
-cx system[4], system[5];
-rz(0.060466255775309286) system[4];
-ry(-0.03969720896057649) system[4];
-rx(0.0874396836489264) system[5];
-rz(2.9507284270126486) system[8];
-ry(-0.07133706577571108) system[8];
-cx system[8], Naimark[0];
-ry(0.03727795909100573) Naimark[0];
-ry(0.09148208132826485) Naimark[0];
-rz(0.2141306628280446) system[8];
-rx(0.0015169954436846655) system[8];
-ry(-0.02420646846586383) system[9];
-rx(0.0016274085362881774) system[9];
-cx system[1], system[9];
-rz(-0.5623594724392595) system[1];
-ry(0.03963678154940564) system[1];
-cx system[1], system[8];
-rz(0.41733591513441026) system[1];
-rx(-0.05984077583854952) system[1];
-ry(0.02838922019871526) system[8];
-rx(-0.0028228116420585536) system[8];
-ry(-0.04155371454950818) system[9];
-cx system[5], system[9];
-rz(-3.0409168946253438) system[5];
-rx(-0.11288558925464542) system[5];
-cx system[5], Naimark[0];
-ry(-0.04473822542252326) Naimark[0];
-cx system[1], Naimark[0];
-ry(-0.02574440517596477) Naimark[0];
-rx(-0.005636549065758389) Naimark[0];
-rz(1.2826395874064411) system[1];
-rx(-0.04225791588566974) system[1];
-rz(-0.9015889398647352) system[5];
-rx(-0.03009966961945465) system[5];
-cx system[5], system[8];
-rz(0.7445856051283412) system[5];
-ry(-0.054524584043191826) system[5];
-cx system[1], system[5];
-rz(0.37091099168271024) system[1];
-rx(-0.0898531103887843) system[1];
-cx system[1], system[4];
-rz(0.7564792893941548) system[1];
-rx(0.09981868556331253) system[1];
-ry(0.12344133435873705) system[4];
-rx(0.0024245345906948046) system[4];
-ry(0.13832268856975505) system[5];
-cx system[1], system[5];
-rz(-1.5753513635986032) system[1];
-ry(-0.03270821544082847) system[1];
-ry(-0.016621300847767584) system[5];
-rx(-0.0012713157358927862) system[5];
-ry(-0.011070386482335604) system[8];
-ry(-0.01745015764595026) system[8];
-ry(0.03466982935076057) system[9];
-cx system[0], system[9];
-rz(0.5303440543333249) system[0];
-rx(-0.0747857776754477) system[0];
-cx system[0], system[8];
-rz(-0.291361770804053) system[0];
-ry(-0.1389306266725212) system[0];
-cx system[0], system[5];
-rz(2.1960785513194647) system[0];
-rx(0.06321166653231858) system[0];
-cx system[0], system[4];
-rz(-0.028653765602788983) system[0];
-rx(-0.11959846497038962) system[0];
-ry(-0.03870090499536838) system[4];
-ry(-0.09366818441174174) system[4];
-ry(-0.11466460599841577) system[5];
-rx(0.008805439279890415) system[5];
-rx(-0.002055429357030958) system[8];
-ry(-0.394681875468919) system[8];
-ry(-0.06064788641082086) system[9];
-rx(-0.0015336520636346496) system[9];
-cx system[1], system[9];
-rz(-0.17415695728317626) system[1];
-ry(0.0010960690587447086) system[1];
-ry(0.03723615393708113) system[9];
-ry(0.06644213517603537) system[9];
-cx system[0], system[9];
-rz(0.10830219207778047) system[0];
-ry(0.1313312713232644) system[0];
-cx system[0], Naimark[0];
-ry(0.08189302119764386) Naimark[0];
-rx(0.0016846656325815168) Naimark[0];
-rz(-0.25290503511083906) system[0];
-rx(0.12805862775623278) system[0];
-cx system[0], system[8];
-rz(2.6981863529702057) system[0];
-ry(0.06693998697527759) system[0];
-cx system[0], system[4];
-rz(3.071286737319054) system[0];
-rx(-0.08168592794383223) system[0];
-rx(-0.0014337668799899728) system[4];
-rx(0.0718854509265685) system[4];
-cx system[4], Naimark[0];
-ry(-0.04012471668101325) Naimark[0];
-rx(0.0012784437756034883) Naimark[0];
-rz(0.6448845966655425) system[4];
-rx(0.08505137767400872) system[4];
-ry(0.08958179102726471) system[8];
-rx(0.005730351508522302) system[8];
-rx(-0.00775267698863602) system[9];
-ry(-0.23062193969579026) system[9];
-cx system[0], system[9];
-rz(0.48155714023882856) system[0];
-ry(0.0827800965674177) system[0];
-cx system[0], system[1];
-rz(1.0680170538671268) system[0];
-ry(0.08619252106664987) system[0];
-rx(-0.0010902753266142096) system[1];
-ry(0.005085954782033886) system[1];
-ry(0.2504325304773376) system[9];
-rx(0.005537036085017766) system[9];
-cx system[0], system[9];
-rz(-0.5717613074707804) system[0];
-rx(0.10628215142116226) system[0];
-cx system[0], system[5];
-rz(0.09079765519686522) system[0];
-rx(-0.06959294142319883) system[0];
-cx system[0], system[8];
-rz(0.20973454851435402) system[0];
-rx(0.10031819775844308) system[0];
-ry(0.055605888538766024) system[5];
-ry(0.06653811687500566) system[5];
-ry(0.030126133746601447) system[8];
-rx(-0.0020961597276425437) system[8];
-ry(-0.238670595031655) system[9];
-rx(-0.004623536631043423) system[9];
-cx system[4], system[9];
-rz(-2.661855934314122) system[4];
-rx(-0.08527350073761375) system[4];
-cx system[4], system[8];
-rz(-0.1998476494051984) system[4];
-ry(-0.04297022074225376) system[4];
-cx system[0], system[4];
-rz(-2.7849458311730793) system[0];
-ry(0.059411390245743156) system[0];
-rx(-0.009589470933319966) system[4];
-rx(0.11490496896779456) system[4];
-ry(0.2753466744203168) system[8];
-ry(-0.032066080762984894) system[8];
-ry(0.2906305776340279) system[9];
-rx(-0.003449301863866161) system[9];
-cx system[0], system[9];
-rz(-0.40195480113888116) system[0];
-rx(-0.20186835265966563) system[0];
-cx system[0], system[1];
-rz(-0.5936042810024307) system[0];
-ry(0.2984549611053353) system[0];
-rx(-0.13575127552725208) system[1];
-ry(-0.1138658130251542) system[9];
-rx(0.0018681198802035226) system[9];
-cx system[4], system[9];
-rz(0.4956137828075491) system[4];
-ry(-0.14233398471874326) system[4];
-cx system[4], Naimark[0];
-ry(-0.0020256314263702446) Naimark[0];
-ry(0.016917054323362768) Naimark[0];
-rz(0.3296212453899574) system[4];
-rx(0.13383590218503838) system[4];
-cx system[4], system[5];
-rz(-0.7299538823430041) system[4];
-rx(-0.2253041737847825) system[4];
-ry(-0.10297200708214094) system[5];
-rx(-0.10785492671022312) system[5];
-ry(0.014726977342930825) system[9];
-ry(0.004424357873839879) system[9];
-cx system[5], system[9];
-rz(-1.0825552703309635) system[5];
-rx(-0.12354014292037108) system[5];
-cx system[5], system[8];
-rz(-1.3327255450052085) system[5];
-rx(0.10700134977535769) system[5];
-ry(-0.02150165088434286) system[8];
-ry(-0.040921142843525216) system[8];
-cx system[4], system[8];
-rz(-3.0165077784432737) system[4];
-ry(0.10721942699433051) system[4];
-cx system[4], Naimark[0];
-ry(0.016909955963348988) Naimark[0];
-ry(-0.013849213350811018) Naimark[0];
-cx system[1], Naimark[0];
-rx(0.008525982198229753) Naimark[0];
-ry(-0.0016211623084037008) Naimark[0];
-rz(0.16014213952223888) system[1];
-rx(-0.24926195834993492) system[1];
-rz(0.9337750932487947) system[4];
-rx(0.20641770348784738) system[4];
-rx(0.1762044810859893) system[8];
-rx(-0.0032417273765092958) system[9];
-ry(0.6056054020082107) system[9];
-cx system[8], system[9];
-rz(-0.24203094093886945) system[8];
-cx system[4], system[8];
-rz(-1.368986365009464) system[4];
-ry(-0.5166676350309127) system[4];
-rx(0.0035204203108085697) system[8];
-rx(0.06013670550180161) system[8];
-cx system[8], Naimark[0];
-rx(-0.0031968166715314883) Naimark[0];
-ry(0.007218043585037082) Naimark[0];
-rz(-0.2640744642441992) system[8];
-rx(0.013587674765100921) system[8];
-cx system[5], system[8];
-rz(-1.0872544057120672) system[5];
-rx(-0.4178980739027367) system[5];
-ry(0.44110596187410867) system[8];
-rx(-0.008850922667052563) system[8];
-ry(-0.43025361473080403) system[9];
-rx(0.0020794168451256922) system[9];
-cx system[1], system[9];
-rz(-0.2319503977186672) system[1];
-ry(0.21459915242482386) system[1];
-cx system[1], system[4];
-rz(-0.13400317563256214) system[1];
-ry(-0.040034220751908434) system[1];
-cx system[1], system[8];
-rz(2.336554940954409) system[1];
-ry(-0.43109598558810136) system[1];
-ry(0.021285237070470142) system[4];
-ry(0.15177411596675205) system[4];
-ry(-0.11711147575717051) system[8];
-rx(0.11448740603139851) system[8];
-ry(-0.13928261987447077) system[9];
-cx system[0], system[9];
-rz(-1.4994430205134193) system[0];
-ry(0.2662551424588313) system[0];
-cx system[0], system[4];
-rz(0.19404541603156344) system[0];
-ry(0.41019736289877273) system[0];
-cx system[0], system[1];
-rz(0.9757422864800007) system[0];
-rx(-0.22899008354397554) system[0];
-cx system[0], system[8];
-rz(-0.43097993078264807) system[0];
-rx(-0.26038289599157705) system[0];
-rx(0.015366706849811784) system[1];
-ry(0.3840418049603911) system[1];
-cx system[0], system[1];
-rz(0.17780867828202584) system[0];
-rx(-0.5275082283320511) system[0];
-ry(-0.2225594714278405) system[1];
-rx(0.3993641158494119) system[1];
-rx(0.092775239486667) system[4];
-ry(1.009272431427935) system[4];
-ry(0.05726105758227318) system[8];
-ry(0.11814497024118209) system[8];
-rx(-0.0059943199557608295) system[9];
-ry(0.3059885458578182) system[9];
-cx system[8], system[9];
-rz(-0.7462186688835626) system[8];
-ry(0.12766951911634217) system[8];
-cx system[5], system[8];
-rz(0.2825300257962977) system[5];
-rx(0.03140621251805942) system[5];
-ry(-0.1074325777895122) system[8];
-ry(-0.41969046446302194) system[8];
-cx system[4], system[8];
-rz(0.1347096567698438) system[4];
-ry(0.7074042146737217) system[4];
-cx system[4], system[5];
-rz(-2.548839895628648) system[4];
-ry(-0.12082456711065381) system[4];
-cx system[4], ancilla[0];
-rz(0.902506756001441) ancilla[0];
-rz(-0.31027577400284834) system[4];
-rz(0.6522620948404828) system[4];
-cx system[4], ancilla[0];
-ry(0.0030079357456544997) ancilla[0];
-rx(-3.1415914730683694) ancilla[0];
-ry(2.5720621305328004) system[4];
-rx(3.1301603542392495) system[4];
-ry(-0.015007284229247908) system[5];
-rx(2.876549947970843) system[5];
-ry(0.02901438214868346) system[8];
-ry(0.5853137058931843) system[8];
-cx system[8], Naimark[0];
-rx(0.17018509010453697) Naimark[0];
-rz(-1.8354993729731843) Naimark[0];
-rz(-0.06014166040857649) system[8];
-ry(-0.3868045312467434) system[8];
-ry(-0.10794626185486034) system[9];
-ry(0.28399112152493156) system[9];
-cx system[0], system[9];
-rz(-0.32353895135774935) system[0];
-ry(-0.9855039222221569) system[0];
-cx system[0], system[8];
-rz(-1.3990109674227673) system[0];
-ry(0.08412752501309795) system[0];
-cx system[0], system[1];
-rx(-0.04174725535065971) system[0];
-rz(2.8648233845523943) system[0];
-cx system[0], Naimark[0];
-rz(0.7485989322823312) Naimark[0];
-rz(0.2827342329340039) Naimark[0];
-ry(0.4961560477853224) system[0];
-rx(-0.004551723549076403) system[0];
-rz(-0.34153839906589) system[1];
-ry(0.5845302822346644) system[1];
-cx system[1], system[2];
-ry(0.02123360876465652) system[1];
-rz(0.03553790436213222) system[2];
-ry(-0.004760148102602724) system[2];
-cx system[2], system[3];
-rz(0.4487867341168277) system[2];
-rz(-2.728262252691723) system[3];
-rx(3.1415926260200457) system[3];
-ry(1.2375733008116148) system[8];
-rx(-0.7173215629078751) system[8];
-ry(-0.5540876384757851) system[9];
-rx(-0.1456420303973338) system[9];
-cx system[5], system[9];
-rz(0.19080047575453074) system[5];
-ry(-0.24909272808783633) system[5];
-cx system[5], system[6];
-ry(-0.023133001258463626) system[5];
-rx(-3.140729951618603) system[5];
-rz(0.22267515796325865) system[6];
-ry(-0.0024204591614060966) system[6];
-cx system[6], system[7];
-rz(0.20775055645975837) system[6];
-rx(3.1415923571646704) system[6];
-rz(3.064820763340073) system[7];
-rx(-0.10315332046222125) system[9];
-rx(-2.1046704610655773) system[9];
-cx system[9], Naimark[0];
-rz(-2.4930064762935715) Naimark[0];
-rx(0.014744786370962437) Naimark[0];
-rz(-0.8950669647447036) system[9];
-rx(1.403106574660132) system[9];
-cx system[8], system[9];
-rx(-1.002390734054222) system[8];
-rz(-2.4613948492245314) system[8];
-rz(-2.3374964486073853) system[9];
-rz(1.2776954221707313) system[9];
-cx system[8], system[9];
-ry(-0.2931773145826284) system[8];
-rx(0.45965008077031144) system[8];
-rx(0.007625686218259542) system[9];
-rx(0.022230607766974275) system[9];
-cx system[9], Naimark[0];
-rx(0.25437914021569696) Naimark[0];
-rx(0.12265636795048418) Naimark[0];
-rx(0.25353036390056394) system[9];
-rx(-2.9292236880862497) system[9];

utils/tempCodeRunnerFile.py

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