Corrected Local Error

app.py

@@ -4,10 +4,10 @@ from trame_vuetify.widgets import vuetify3
 from trame.widgets import html as trame_html
 import os
 
-# Import pages
-# from pages import em_page   # <-- remove eager import to avoid side effects
-em_page = None                # lazy-import in EM tab
-import qlbm as qlbm_page
+# 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")
@@ -73,23 +73,19 @@ with SinglePageLayout(server) as layout:
         with vuetify3.VContainer(v_if="current_page === 'EM'", fluid=True, classes="pa-0 fill-height"):
             try:
                 if not globals().get("em_page"):
-                    from importlib import import_module
-                    mod = import_module("pages.em_page")
-                    globals()["em_page"] = mod
-                if hasattr(em_page, "build"):
-                    em_page.build(server)
-                else:
-                    trame_html.Div("EM module missing build(server).", style="padding:8px;color:#666;")
+                    globals()["em_page"] = import_module("pages.em_page")
+                em_page.build(server)
             except Exception as e:
-                trame_html.Div(
-                    f"EM page failed to load in embedded mode: {e}. "
-                    "Refactor EM to avoid starting a secondary server/iframe.",
-                    style="padding:8px;color:#b00020;"
-                )
+                trame_html.Div(f"EM embed failed: {e}", style="padding:8px;color:#b00020;")
 
         # Mount QLBM page
         with vuetify3.VContainer(v_if="current_page === 'QLBM'", fluid=True, classes="pa-0 fill-height"):
-            qlbm_page.build(server)
+            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;")
 
 if __name__ == "__main__":
     # If PORT is provided (e.g., Hugging Face), bind on 0.0.0.0; otherwise use localhost

em.ipynb

@@ -0,0 +1,254 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fe68f8a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Available backends: [<qiskit_ionq.ionq_backend.IonQSimulatorBackend object at 0x7f91854ff520>, <qiskit_ionq.ionq_backend.IonQQPUBackend object at 0x7f91851f8d90>]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cudaq/.local/lib/python3.10/site-packages/qiskit_ionq/ionq_backend.py:127: IonQTranspileLevelWarning: Transpiler default optimization_level=2. IonQ (QIS) recommends 0-1 to avoid aggressive re-synthesis; use transpile(..., optimization_level=1).\n",
+      "  warn_bad_transpile_level()\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit import QuantumCircuit\n",
+    "from qiskit_ionq import IonQProvider\n",
+    "import os\n",
+    "my_api_key = os.getenv(\"IONQ_API_KEY\")\n",
+    "# # provider = IonQProvider()\n",
+    "\n",
+    "api_token = \"SgUkiDq1r2bVEadyiUfvtuxQ03Qci6UW\"\n",
+    "provider = IonQProvider(api_token)\n",
+    "\n",
+    "\n",
+    "backends = provider.backends()\n",
+    "print(\"Available backends:\", backends)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "6b2b90ef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cudaq/.local/lib/python3.10/site-packages/qiskit_ionq/ionq_backend.py:127: IonQTranspileLevelWarning: Transpiler default optimization_level=2. IonQ (QIS) recommends 0-1 to avoid aggressive re-synthesis; use transpile(..., optimization_level=1).\n",
+      "  warn_bad_transpile_level()\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expectation values: [1.55664062]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit import QuantumCircuit\n",
+    "from qiskit_ionq import IonQProvider\n",
+    "\n",
+    "backend = provider.get_backend(\"simulator\")\n",
+    "\n",
+    "from qiskit.circuit.library import real_amplitudes\n",
+    "from qiskit.quantum_info import SparsePauliOp\n",
+    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
+    "from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator\n",
+    "from qiskit.primitives import StatevectorEstimator\n",
+    "\n",
+    "# service = QiskitRuntimeService()\n",
+    "# backend = service.least_busy(operational=True, simulator=False)\n",
+    " \n",
+    "psi = real_amplitudes(num_qubits=2, reps=2)\n",
+    "hamiltonian = SparsePauliOp.from_list([(\"II\", 1), (\"IZ\", 2), (\"XI\", 3)])\n",
+    "theta = [0, 1, 1, 2, 3, 5]\n",
+    " \n",
+    "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n",
+    "isa_psi = pm.run(psi)\n",
+    "isa_observables = hamiltonian.apply_layout(isa_psi.layout)\n",
+    " \n",
+    "estimator = Estimator(mode=backend)\n",
+    " \n",
+    "# calculate [ <psi(theta)|hamiltonian|psi(theta)> ]\n",
+    "job = estimator.run([(isa_psi, isa_observables, [theta])])\n",
+    "pub_result = job.result()[0]\n",
+    "print(f\"Expectation values: {pub_result.data.evs}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "4147b18a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expectation values: [1.55555728]\n"
+     ]
+    }
+   ],
+   "source": [
+    "qiskit_estimator = StatevectorEstimator()\n",
+    "job2 = qiskit_estimator.run([(psi, hamiltonian, [theta])])\n",
+    "pub_result = job2.result()[0]\n",
+    "print(f\"Expectation values: {pub_result.data.evs}\")                             "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "109a7251",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_sim_ionq(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, progress_callback=None):\n",
+    "    \"\"\"\n",
+    "    Runs the quantum simulation for electromagnetic scattering with fixed dt=0.1.\n",
+    "    Captures frames only at user-defined snapshot times: [0, Δt, 2Δt, ..., ≤ T_eff],\n",
+    "    always including t=0 and the final solver-aligned T (T_eff = floor(T/dt)*dt).\n",
+    "\n",
+    "    Returns:\n",
+    "        frames (np.ndarray), snapshot_times (np.ndarray)\n",
+    "    \"\"\"\n",
+    "    dt = 0.1\n",
+    "    # Validate total time and compute solver-aligned end time\n",
+    "    try:\n",
+    "        T_val = float(T)\n",
+    "    except Exception:\n",
+    "        return np.array([]), np.array([])\n",
+    "    if T_val <= 0:\n",
+    "        return np.array([]), np.array([])\n",
+    "\n",
+    "    steps = int(np.floor(T_val / dt))\n",
+    "    if steps <= 0:\n",
+    "        return np.array([]), np.array([])\n",
+    "    T_eff = steps * dt\n",
+    "\n",
+    "    # Determine snapshot Δt on solver grid\n",
+    "    tol = 1e-12\n",
+    "    if snapshot_dt is None:\n",
+    "        snapshot_dt_val = dt\n",
+    "    else:\n",
+    "        try:\n",
+    "            snapshot_dt_val = float(snapshot_dt)\n",
+    "        except Exception:\n",
+    "            snapshot_dt_val = dt\n",
+    "    if snapshot_dt_val < dt - tol:\n",
+    "        snapshot_dt_val = dt\n",
+    "    k = max(1, int(round(snapshot_dt_val / dt)))\n",
+    "    snapshot_dt_eff = k * dt\n",
+    "\n",
+    "    # Build requested snapshot times on solver grid\n",
+    "    target_times = [0.0]\n",
+    "    t = 0.0\n",
+    "    while t + snapshot_dt_eff <= T_eff + tol:\n",
+    "        t = round(t + snapshot_dt_eff, 12)\n",
+    "        if t <= T_eff + tol:\n",
+    "            target_times.append(min(t, T_eff))\n",
+    "    if abs(target_times[-1] - T_eff) > tol:\n",
+    "        target_times.append(T_eff)\n",
+    "\n",
+    "    # Setup circuit\n",
+    "    nq = int(np.ceil(np.log2(nx)))\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",
+    "    system, ancilla = QuantumRegister(2 * nq + 2), QuantumRegister(na)\n",
+    "    qc = QuantumCircuit(system, ancilla)\n",
+    "    qc.append(StatePreparation(initial_state), system)\n",
+    "    qc.append(StatePreparation(fp / np.linalg.norm(fp)), ancilla)\n",
+    "    expA1 = V1(nx, dt).to_gate()\n",
+    "    expA2 = V2(nx, dt)\n",
+    "\n",
+    "    frames = []\n",
+    "    \n",
+    "     # Run the circuit on IonQ's platform:\n",
+    "    job = simulator_backend.run(qc, shots=10000)\n",
+    "\n",
+    "    # Print the counts\n",
+    "    # print(job.get_counts())\n",
+    "    # # Capture initial frame at t=0\n",
+    "    # sv0 = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))\n",
+    "    # frames.append(sv0[2 ** (na - 1)])\n",
+    "    # next_idx = 1  # next target_times index to capture\n",
+    "\n",
+    "    # for i in range(steps):\n",
+    "    #     if stop_check and stop_check():\n",
+    "    #         print(f\"Simulation interrupted at step {i}/{steps}\")\n",
+    "    #         break\n",
+    "    #     # One solver step\n",
+    "    #     qc.append(QFTGate(na), ancilla)\n",
+    "    #     qc.x(ancilla[-1])\n",
+    "    #     for j in range(na - 1):\n",
+    "    #         qc.append(expA1.control().repeat(2 ** j), [ancilla[j]] + system[:])\n",
+    "    #     qc.append(expA1.inverse().control(ctrl_state=\"0\").repeat(2 ** (na - 1)), [ancilla[na - 1]] + system[:])\n",
+    "    #     qc.append(expA2, system[:])\n",
+    "    #     qc.x(ancilla[-1])\n",
+    "    #     qc.append(QFTGate(na).inverse(), ancilla)\n",
+    "\n",
+    "    #     current_time = (i + 1) * dt\n",
+    "    #     if next_idx < len(target_times) and abs(current_time - target_times[next_idx]) <= tol:\n",
+    "    #         u = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))\n",
+    "    #         frames.append(u[2 ** (na - 1)])\n",
+    "    #         next_idx += 1\n",
+    "\n",
+    "    #     if progress_callback:\n",
+    "    #         try:\n",
+    "    #             progress = ((i + 1) / steps) * 100\n",
+    "    #             progress_callback(progress)\n",
+    "    #         except Exception:\n",
+    "    #             pass\n",
+    "\n",
+    "    # if progress_callback:\n",
+    "    #     try:\n",
+    "    #         progress_callback(100.0)\n",
+    "    #     except Exception:\n",
+    "    #         pass\n",
+    "\n",
+    "    # # Ensure snapshot_times align with number of captured frames (covers early stop)\n",
+    "    # frames_arr = np.asarray(frames)\n",
+    "    # times_arr = np.asarray(target_times[: len(frames_arr)])\n",
+    "    # return frames_arr, times_arr\n",
+    "\n"
+   ]
+  }
+ ],
+ "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.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

em_trame.py

@@ -2600,9 +2600,16 @@ def build(host_server):
 update_initial_state_preview()
 
 if __name__ == "__main__":
-    # Allow running standalone on a dedicated port (default 8701)
-    # so it can be embedded via IFrame in the multipage app
+    # Standalone launch: prefer IPv4 loopback to avoid OSError 99 on ::1
     port = int(os.environ.get("EM_APP_PORT", "8701"))
-    server.start(port=port, open_browser=False)
+    host = os.environ.get("EM_HOST", "127.0.0.1")
+    try:
+        server.start(host=host, port=port, open_browser=False)
+    except OSError as e:
+        # Fallback: try any local interface
+        try:
+            server.start(host="0.0.0.0", port=port, open_browser=False)
+        except Exception:
+            print(f"EM server failed to bind on {host}:{port} -> {e}")
 
 

fluid.py

@@ -0,0 +1,1043 @@
+import os
+import math
+import tempfile
+import gradio as gr
+import cudaq
+import numpy as np
+import cupy as cp
+from pathlib import Path
+import plotly.graph_objects as go
+import plotly.io as pio
+from sympy import sympify, symbols, lambdify
+from gradio_litmodel3d import LitModel3D
+import zipfile
+
+# Set Plotly engine for image export
+try:
+    pio.kaleido.scope.mathjax = None
+except AttributeError:
+    pass
+
+# Existing functions (bin_to_gray, gray_to_bin, etc.) remain unchanged
+def bin_to_gray(bin_s):
+    XOR=lambda x,y: (x or y) and not (x and y)
+    gray_s=bin_s[0]
+    for i in range(len(bin_s)-1):
+        c_bool=XOR(bool(int(bin_s[i])),bool(int(bin_s[i+1])))
+        gray_s+=str(int(c_bool))
+    return gray_s
+
+def gray_to_bin(gray_s):
+  XOR=lambda x,y: (x or y) and not (x and y)
+  bin_s=gray_s[0]
+  for i in range(len(gray_s)-1):
+    c_bool=XOR(bool(int(bin_s[i])),bool(int(gray_s[i+1])))
+    bin_s+=str(int(c_bool))
+  return bin_s
+
+def bin_to_int(bin_s):
+  return int(bin_s,2)
+
+def int_to_bin(i,pad):
+  return bin(i)[2:].zfill(pad)
+
+def fwht_approx(f,N,num_points_per_dim,threshold=1e-10):
+  linear_block_size=int(N//num_points_per_dim)
+  num_angles_per_block=int(np.log2(linear_block_size))
+
+  thetas={}
+
+  for k in range(num_points_per_dim):
+    for j in range(num_points_per_dim):
+      for i in range(num_points_per_dim):
+
+        avg_f=2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2))
+        thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size]=avg_f
+
+        slope_x=(2*np.arccos(f(i*linear_block_size,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2))-2*np.arccos(f(((i+1)%N)*linear_block_size,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2)))/linear_block_size
+        slope_y=(2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size,k*linear_block_size+(linear_block_size-1)/2))-2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,((j+1)%N)*linear_block_size,k*linear_block_size+(linear_block_size-1)/2)))/linear_block_size
+        slope_z=(2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size))-2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,((k+1)%N)*linear_block_size)))/linear_block_size
+
+        for m in range(num_angles_per_block):
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + 2**m]=slope_x*(2**(m-1))
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + N*(2**m)]=slope_y*(2**(m-1))
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + (N**2)*(2**m)]=slope_z*(2**(m-1))
+
+  h = linear_block_size
+  while h < N**3:
+    for i in range(0, N**3, h * 2):
+      if (i//N)%linear_block_size!=0:
+        continue
+      if (i//(N**2))%linear_block_size!=0:
+        continue
+      j=i
+      while j<i+h:
+        index=j
+        x = thetas[index]
+        y = thetas[index + h]
+        thetas[index] = (x + y)/2
+        thetas[index + h] = (x - y)/2
+
+        for ax in range(3):
+          for m in range(num_angles_per_block):
+            index = j + (N**ax) * (2**m)
+            x = thetas[index]
+            y = thetas[index + h]
+            thetas[index] = (x + y)/2
+            thetas[index + h] = (x - y)/2
+
+        j+=linear_block_size
+        if (j//N)%linear_block_size==1:
+          j+=(linear_block_size-1)*N
+        if (j//(N**2))%linear_block_size==1:
+          j+=(linear_block_size-1)*(N**2)
+
+    h *= 2
+    if h==N:
+      h=N*linear_block_size
+    if h==N**2:
+      h=(N**2)*linear_block_size
+
+  return [theta for theta in thetas.values() if abs(theta)>threshold],[key for key in thetas.keys() if abs(thetas[key])>threshold]
+
+def get_circuit_inputs(f,num_reg_qubits,num_points_per_dim):
+  theta_vec,indices=fwht_approx(f,2**num_reg_qubits,num_points_per_dim)
+  circ_pos=[]
+  for ind in indices:
+    circ_pos+=[bin_to_int(gray_to_bin(int_to_bin(ind,num_reg_qubits*3)))]
+
+  sorted_theta_vec=sorted(zip(theta_vec,circ_pos),key=lambda el:el[1])
+  ctrls=[]
+
+  current_bs="0"*(3*num_reg_qubits)
+  for el in sorted_theta_vec:
+    new_bs=bin_to_gray(int_to_bin((el[1])%(2**(3*num_reg_qubits)),(3*num_reg_qubits)))
+    ctrls += [[i for i, (char1, char2) in enumerate(zip(current_bs, new_bs)) if char1 != char2]]
+    current_bs=new_bs
+  new_bs="0"*(3*num_reg_qubits)
+  ctrls += [[i for i, (char1, char2) in enumerate(zip(current_bs, new_bs)) if char1 != char2]]
+
+  ctrls_flat_list=[]
+  for ctrl_list in ctrls:
+    ctrls_flat_list+=[len(ctrl_list)]+ctrl_list
+
+  return [el[0] for el in sorted_theta_vec]+[0.0],ctrls_flat_list
+
+# Simulation functions remain unchanged
+def simulate_qlbm_and_animate(num_reg_qubits: int, T: int, distribution_type: str, velocity_field: str, vx_input: float, vy_input: float, boundary_condition: str):
+    num_anc = 3
+    num_qubits_total = 2 * num_reg_qubits + num_anc
+    current_N = 2**num_reg_qubits
+    N_tot_state_vector = 2**num_qubits_total
+    num_ranks = 1
+    rank = 0
+    N_sub_per_rank = int(N_tot_state_vector // num_ranks)
+    NUM_ANIMATION_FRAMES = 40
+
+    if T == 0:
+        time_steps = [0]
+    else:
+        num_points = min(T + 1, NUM_ANIMATION_FRAMES)
+        time_steps = np.linspace(start=0, stop=T, num=num_points, dtype=int)
+        time_steps = sorted(list(set(time_steps)))
+
+    if distribution_type == "Sinusoidal":
+        selected_initial_state_function_raw = lambda x, y, N_val_func: \
+            np.sin(x * 2 * np.pi / N_val_func) * (1 - 0.5 * x / N_val_func) * \
+            np.sin(y * 4 * np.pi / N_val_func) * (1 - 0.5 * y / N_val_func) + 1
+    elif distribution_type == "Gaussian":
+        selected_initial_state_function_raw = lambda x, y, N_val_func: \
+            np.exp(-((x - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) +
+                     (y - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2))) * 1.8 + 0.2
+    elif distribution_type == "Random":
+        selected_initial_state_function_raw = lambda x, y, N_val_func: \
+            np.random.rand(N_val_func, N_val_func) * 1.5 + 0.2 if isinstance(x, int) else \
+            np.random.rand(x.shape[0], x.shape[1]) * 1.5 + 0.2
+    else:
+        print(f"Warning: Unknown distribution type '{distribution_type}'. Defaulting to Sinusoidal.")
+        selected_initial_state_function_raw = lambda x, y, N_val_func: \
+            np.sin(x * 2 * np.pi / N_val_func) * (1 - 0.5 * x / N_val_func) * \
+            np.sin(y * 4 * np.pi / N_val_func) * (1 - 0.5 * y / N_val_func) + 1
+
+    initial_state_func_eval = lambda x_coords, y_coords: \
+        selected_initial_state_function_raw(x_coords, y_coords, current_N) * \
+        (y_coords < current_N).astype(int)
+
+    if velocity_field == "User":
+        pass
+    elif velocity_field == "Shear":
+        vx_input = vx_input * (current_N / 2)
+    elif velocity_field == "TGV":
+        vx_input = vx_input * np.sin(np.pi * current_N / 10)
+        vy_input = vy_input * np.cos(np.pi * current_N / 10)
+    elif velocity_field == "Swirl":
+        vx_input = vx_input * np.cos(np.pi * current_N / 5)
+        vy_input = vy_input * np.sin(np.pi * current_N / 5)
+
+    with tempfile.TemporaryDirectory() as tmp_npy_dir:
+        intermediate_folder_path = Path(tmp_npy_dir)
+        cudaq.set_target('nvidia', option='fp64')
+
+        @cudaq.kernel
+        def alloc_kernel(num_qubits_alloc: int):
+            qubits = cudaq.qvector(num_qubits_alloc)
+
+        from cupy.cuda.memory import MemoryPointer, UnownedMemory
+
+        def to_cupy_array(state):
+            tensor = state.getTensor()
+            pDevice = tensor.data()
+            sizeByte = tensor.get_num_elements() * tensor.get_element_size()
+            mem = UnownedMemory(pDevice, sizeByte, owner=state)
+            memptr_obj = MemoryPointer(mem, 0)
+            cupy_array_val = cp.ndarray(tensor.get_num_elements(),
+                                        dtype=cp.complex128,
+                                        memptr=memptr_obj)
+            return cupy_array_val
+
+        class QLBMAdvecDiffD2Q5_new:
+            def __init__(self, vx=0.2, vy=0.15) -> None:
+                self.dim = 2
+                self.ndir = 5
+                self.nq_dir = math.ceil(np.log2(self.ndir))
+                self.dirs = []
+                for dir_int in range(self.ndir):
+                    dir_bin = f"{dir_int:b}".zfill(self.nq_dir)
+                    self.dirs.append(dir_bin)
+                self.e_unitvec = np.array([0, 1, -1, 1, -1])
+                self.wts = np.array([2/6, 1/6, 1/6, 1/6, 1/6])
+                self.cs = 1 / np.sqrt(3)
+                self.vx = vx
+                self.vy = vy
+                self.u = np.array([0, self.vx, self.vx, self.vy, self.vy])
+                self.wtcoeffs = np.multiply(self.wts, 1 + self.e_unitvec * self.u / self.cs**2)
+                self.create_circuit()
+
+            def create_circuit(self):
+                v = np.pad(self.wtcoeffs, (0, 2**num_anc - self.ndir))
+                v = v**0.5
+                v = v / np.linalg.norm(v)
+                U_prep = 2 * np.outer(v, v) - np.eye(len(v))
+                cudaq.register_operation("prep_op", U_prep)
+
+                def collisionOp(dirs_list):
+                    dirs_i_list_val = []
+                    for dir_str in dirs_list:
+                        dirs_i = [(int(c)) for c in dir_str]
+                        dirs_i_list_val += dirs_i[::-1]
+                    return dirs_i_list_val
+
+                self.dirs_i_list = collisionOp(self.dirs)
+
+                @cudaq.kernel
+                def rshift(q: cudaq.qview, n: int):
+                    for i in range(n):
+                        if i == n - 1:
+                            x(q[n - 1 - i])
+                        elif i == n - 2:
+                            x.ctrl(q[n - 1 - (i + 1)], q[n - 1 - i])
+                        else:
+                            x.ctrl(q[0:n - 1 - i], q[n - 1 - i])
+
+                @cudaq.kernel
+                def lshift(q: cudaq.qview, n: int):
+                    for i in range(n):
+                        if i == 0:
+                            x(q[0])
+                        elif i == 1:
+                            x.ctrl(q[0], q[1])
+                        else:
+                            x.ctrl(q[0:i], q[i])
+
+                @cudaq.kernel
+                def d2q5_tstep(q: cudaq.qview, nqx: int, nqy: int, nq_dir_val: int, dirs_i_val: list[int]):
+                    qx = q[0:nqx]
+                    qy = q[nqx:nqx + nqy]
+                    qdir = q[nqx + nqy:nqx + nqy + nq_dir_val]
+
+                    idx_lqx = 2
+                    b_list = dirs_i_val[idx_lqx * nq_dir_val:(idx_lqx + 1) * nq_dir_val]
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+                    cudaq.control(lshift, qdir, qx, nqx)
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+
+                    idx_rqx = 1
+                    b_list = dirs_i_val[idx_rqx * nq_dir_val:(idx_rqx + 1) * nq_dir_val]
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+                    cudaq.control(rshift, qdir, qx, nqx)
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+
+                    idx_lqy = 4
+                    b_list = dirs_i_val[idx_lqy * nq_dir_val:(idx_lqy + 1) * nq_dir_val]
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+                    cudaq.control(lshift, qdir, qy, nqy)
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+
+                    idx_rqy = 3
+                    b_list = dirs_i_val[idx_rqy * nq_dir_val:(idx_rqy + 1) * nq_dir_val]
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+                    cudaq.control(rshift, qdir, qy, nqy)
+                    for j in range(nq_dir_val):
+                        if b_list[j] == 0: x(qdir[j])
+
+                @cudaq.kernel
+                def d2q5_tstep_wrapper(state_arg: cudaq.State, nqx: int, nqy: int, nq_dir_val: int, dirs_i_val: list[int]):
+                    q = cudaq.qvector(state_arg)
+                    qdir = q[nqx + nqy:nqx + nqy + nq_dir_val]
+                    prep_op(qdir[2], qdir[1], qdir[0])
+                    d2q5_tstep(q, nqx, nqy, nq_dir_val, dirs_i_val)
+                    prep_op(qdir[2], qdir[1], qdir[0])
+
+                def run_timestep_func(vec_arg, hadamard=False):
+                    result = cudaq.get_state(d2q5_tstep_wrapper, vec_arg, num_reg_qubits, num_reg_qubits, self.nq_dir, self.dirs_i_list)
+                    num_nonzero_ranks = num_ranks / (2**num_anc)
+                    rank_slice_cupy = to_cupy_array(result)
+                    if rank >= num_nonzero_ranks and num_nonzero_ranks > 0:
+                        sub_sv_zeros = np.zeros(N_sub_per_rank, dtype=np.complex128)
+                        cp.cuda.runtime.memcpy(rank_slice_cupy.data.ptr, sub_sv_zeros.ctypes.data, sub_sv_zeros.nbytes, cp.cuda.runtime.memcpyHostToDevice)
+                    if rank == 0 and num_nonzero_ranks < 1 and N_sub_per_rank > 0:
+                        limit_idx = int(N_tot_state_vector / (2**num_anc))
+                        if limit_idx < rank_slice_cupy.size:
+                            rank_slice_cupy[limit_idx:] = 0
+                    return result
+                self.run_timestep = run_timestep_func
+
+            def write_state(self, state_to_write, t_step_str_val):
+                rank_slice_cupy = to_cupy_array(state_to_write)
+                num_nonzero_ranks = num_ranks / (2**num_anc)
+                if rank < num_nonzero_ranks or (rank == 0 and num_nonzero_ranks <= 0):
+                    save_path = intermediate_folder_path / f"{t_step_str_val}_{rank}.npy"
+                    with open(save_path, 'wb') as f:
+                        arr_to_save = None
+                        data_limit = N_sub_per_rank
+                        if num_nonzero_ranks < 1 and rank == 0:
+                            data_limit = int(N_tot_state_vector / (2**num_anc))
+                        if data_limit > 0:
+                            relevant_part_cupy = cp.real(rank_slice_cupy[:data_limit])
+                        else:
+                            relevant_part_cupy = cp.array([], dtype=cp.float64)
+                        if relevant_part_cupy.size >= current_N * current_N:
+                            arr_flat = relevant_part_cupy[:current_N * current_N]
+                            if downsampling_factor > 1 and current_N > 0:
+                                arr_reshaped = arr_flat.reshape((current_N, current_N))
+                                arr_downsampled = arr_reshaped[::downsampling_factor, ::downsampling_factor]
+                                arr_to_save = arr_downsampled.flatten()
+                            else:
+                                arr_to_save = arr_flat
+                        elif relevant_part_cupy.size > 0:
+                            if downsampling_factor > 1:
+                                arr_to_save = relevant_part_cupy[::downsampling_factor]
+                            else:
+                                arr_to_save = relevant_part_cupy
+                        if arr_to_save is not None and arr_to_save.size > 0:
+                            np.save(f, arr_to_save.get() if isinstance(arr_to_save, cp.ndarray) else arr_to_save)
+
+            def run_evolution(self, initial_state_arg, total_timesteps, time_steps_to_save, observable=False):
+                current_state_val = initial_state_arg
+                save_times = set(time_steps_to_save)
+                if 0 in save_times:
+                    self.write_state(current_state_val, '0')
+                for t_iter in range(total_timesteps):
+                    if (t_iter + 1) in save_times:
+                        next_state_val = self.run_timestep(current_state_val)
+                        self.write_state(next_state_val, str(t_iter + 1))
+                        current_state_val = next_state_val
+                    else:
+                        current_state_val = self.run_timestep(current_state_val)
+                    cp.get_default_memory_pool().free_all_blocks()
+                if rank == 0:
+                    print(f"Timestep: {total_timesteps}/{total_timesteps} (Evolution complete)")
+                cp.get_default_memory_pool().free_all_blocks()
+                self.final_state = current_state_val
+
+        if boundary_condition == "Periodic":
+            pass
+        elif boundary_condition == "Dirichlet":
+            pass
+        elif boundary_condition == "Neumann":
+            pass
+
+        downsampling_factor = 2**5
+        if current_N == 0:
+            print("Error: current_N is zero. num_reg_qubits likely too small.")
+            return None, None # Modified return
+        if current_N < downsampling_factor:
+            downsampling_factor = current_N if current_N > 0 else 1
+
+        qlbm_obj = QLBMAdvecDiffD2Q5_new(vx=vx_input, vy=vy_input)
+        initial_state_val = cudaq.get_state(alloc_kernel, num_qubits_total)
+
+        xv_init = np.arange(current_N)
+        yv_init = np.arange(current_N)
+        initial_grid_2d_X, initial_grid_2d_Y = np.meshgrid(xv_init, yv_init)
+
+        if distribution_type == "Random":
+            initial_grid_2d = selected_initial_state_function_raw(current_N, current_N, current_N)
+        else:
+            initial_grid_2d = initial_state_func_eval(initial_grid_2d_X, initial_grid_2d_Y)
+
+        sub_sv_init_flat = initial_grid_2d.flatten().astype(np.complex128)
+        norm = np.linalg.norm(sub_sv_init_flat)
+        if norm > 0:
+            sub_sv_init_flat /= norm
+        else:
+            print("Error: Initial state norm is zero.")
+            return None, None # Modified return
+        full_initial_sv_host = np.zeros(N_sub_per_rank, dtype=np.complex128)
+        num_computational_states = current_N * current_N
+        if len(sub_sv_init_flat) == num_computational_states:
+            if num_computational_states <= N_sub_per_rank:
+                full_initial_sv_host[:num_computational_states] = sub_sv_init_flat
+            else:
+                print(f"Error: Grid data {num_computational_states} > N_sub_per_rank {N_sub_per_rank}")
+                return None, None # Modified return
+        else:
+            print(f"Warning: Initial state size {len(sub_sv_init_flat)} != expected {num_computational_states}")
+            fill_len = min(len(sub_sv_init_flat), num_computational_states, N_sub_per_rank)
+            full_initial_sv_host[:fill_len] = sub_sv_init_flat[:fill_len]
+
+        rank_slice_init = to_cupy_array(initial_state_val)
+        print(f'Rank {rank}: Initializing state with {distribution_type} (vx={vx_input}, vy={vy_input})...')
+        cp.cuda.runtime.memcpy(rank_slice_init.data.ptr, full_initial_sv_host.ctypes.data, full_initial_sv_host.nbytes, cp.cuda.runtime.memcpyHostToDevice)
+        print(f'Rank {rank}: Initial state copied. Size: {len(sub_sv_init_flat)}. N_sub_per_rank: {N_sub_per_rank}')
+
+        print("Starting QLBM evolution...")
+        qlbm_obj.run_evolution(initial_state_val, T, time_steps)
+        print("QLBM evolution complete.")
+
+        print("Generating interactive plot with Plotly...")
+        downsampled_N = current_N // downsampling_factor
+        if downsampled_N == 0 and current_N > 0:
+            downsampled_N = 1
+        elif current_N == 0:
+            print("Error: current_N is zero before Plotly stage.")
+            return None, None # Modified return
+
+        data_frames = []
+        actual_timesteps = []
+        for t in time_steps:
+            file_path = intermediate_folder_path / f"{t}_{rank}.npy"
+            if file_path.exists():
+                sol_loaded = np.load(file_path)
+                if sol_loaded.size == downsampled_N * downsampled_N:
+                    Z_data = np.reshape(sol_loaded, (downsampled_N, downsampled_N))
+                    data_frames.append(Z_data)
+                    actual_timesteps.append(t)
+                    print(f"Time {t}: Min={np.min(Z_data)}, Max={np.max(Z_data)}, Mean={np.mean(Z_data)}")
+                else:
+                    print(f"Warning: File {file_path} size {sol_loaded.size} != expected {downsampled_N*downsampled_N}. Skipping.")
+            else:
+                print(f"Warning: File {file_path} not found. Skipping.")
+
+        if not data_frames:
+            print("Error: No data frames loaded for plotting.")
+            return None, None # Modified return
+
+        x_coords_plot = np.linspace(0, 1, downsampled_N)
+        y_coords_plot = np.linspace(0, 1, downsampled_N)
+
+        z_min = min([np.min(Z) for Z in data_frames])
+        z_max = max([np.max(Z) for Z in data_frames])
+        if z_max == z_min:
+            z_max += 1e-9
+
+        fig = go.Figure()
+        
+        # Store individual frames for download
+        plotly_json_frames = []
+
+        for i, Z in enumerate(data_frames):
+            frame_trace = go.Surface(
+                z=Z, x=x_coords_plot, y=y_coords_plot,
+                colorscale='Blues',
+                cmin=z_min, cmax=z_max,
+                name=f'Time: {actual_timesteps[i]}',
+                showscale=False
+            )
+            fig.add_trace(frame_trace)
+            
+            # Create a figure for the individual frame and convert to JSON
+            single_frame_fig = go.Figure(data=[frame_trace], layout=fig.layout)
+            single_frame_fig.update_layout(
+                title=f"Time: {actual_timesteps[i]}",
+                scene=dict(
+                    xaxis_title='X',
+                    yaxis_title='Y',
+                    zaxis_title='Density',
+                    xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+                    yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+                    zaxis=dict(range=[z_min, z_max]),
+                )
+            )
+            plotly_json_frames.append(single_frame_fig.to_json())
+
+
+        for trace in fig.data[1:]:
+            trace.visible = False
+
+        steps = []
+        for i in range(len(data_frames)):
+            step = dict(
+                method="update",
+                args=[{"visible": [False] * len(data_frames)}],
+                label=f"Time: {actual_timesteps[i]}"
+            )
+            step["args"][0]["visible"][i] = True
+            steps.append(step)
+
+        sliders = [dict(active=0, currentvalue={"prefix": "Time: "}, pad={"t": 50}, steps=steps)]
+
+        # fig.update_layout(
+        #     title='', # Removed graph title
+        #     scene=dict(
+        #         xaxis_title='X',
+        #         yaxis_title='Y',
+        #         zaxis_title='Density',
+        #         xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+        #         yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+        #         zaxis=dict(range=[z_min, z_max]),
+        #     ),
+        #     sliders=sliders,
+        #     width=800,
+        #     height=700
+        # )
+        fig.update_layout(
+            title='', # Removed graph title
+            scene=dict(
+                xaxis_title='X',
+                yaxis_title='Y',
+                zaxis_title='Density',
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False),
+            ),
+            sliders=sliders,
+            width=800,
+            height=700
+        )
+        return fig, plotly_json_frames # Modified return
+
+def simulate_qlbm_3D_and_animate(num_reg_qubits: int, T: int, distribution_type: str, vx_input, vy_input, vz_input, boundary_condition: str):
+    num_anc = 3
+    num_qubits_total = 3 * num_reg_qubits + num_anc
+    current_N = 2**num_reg_qubits
+    N_tot_state_vector = 2**num_qubits_total
+    num_ranks = 1
+    rank = 0
+    N_sub_per_rank = int(N_tot_state_vector // num_ranks)
+
+    # Simplified time steps for 3D since slider steps are removed
+    NUM_ANIMATION_FRAMES_3D = 10 # Default number of frames if no specific slider steps
+
+    if T == 0:
+        time_steps = [0]
+    else:
+        num_points = min(T + 1, NUM_ANIMATION_FRAMES_3D)
+        time_steps = np.linspace(start=0, stop=T, num=num_points, dtype=int)
+        time_steps = sorted(list(set(time_steps)))
+
+
+    if distribution_type == "Sinusoidal":
+        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
+            np.sin(x * 2 * np.pi / N_val_func) * \
+            np.sin(y * 2 * np.pi / N_val_func) * \
+            np.sin(z * 2 * np.pi / N_val_func) + 1
+    elif distribution_type == "Gaussian":
+        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
+            np.exp(-((x - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) + (y - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) +
+                     (z - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2))) * 1.8 + 0.2
+    else:
+        print(f"Warning: Unknown distribution type '{distribution_type}'. Defaulting to Sinusoidal.")
+        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
+            np.sin(x * 2 * np.pi / N_val_func) * \
+            np.sin(y * 2 * np.pi / N_val_func) * \
+            np.sin(z * 2 * np.pi / N_val_func) + 1
+
+    initial_state_func_eval = lambda i:\
+        selected_initial_state_function_raw(i%current_N,(i//current_N)%current_N,i//(current_N**2),current_N)*(i<(current_N**3)).astype(int)
+
+    with tempfile.TemporaryDirectory() as tmp_npy_dir:
+        intermediate_folder_path = Path(tmp_npy_dir)
+
+        cudaq.set_target('nvidia', option='fp64')
+
+        @cudaq.kernel
+        def alloc_kernel(num_qubits_alloc: int):
+            qubits = cudaq.qvector(num_qubits_alloc)
+
+        from cupy.cuda.memory import MemoryPointer, UnownedMemory
+
+        def to_cupy_array(state):
+            tensor = state.getTensor()
+            pDevice = tensor.data()
+            sizeByte = tensor.get_num_elements() * tensor.get_element_size()
+            mem = UnownedMemory(pDevice, sizeByte, owner=state)
+            memptr_obj = MemoryPointer(mem, 0)
+            cupy_array_val = cp.ndarray(tensor.get_num_elements(),
+                                      dtype=cp.complex128,
+                                      memptr=memptr_obj)
+            return cupy_array_val
+
+        class QLBMAdvecDiffD3Q7_new:
+            def __init__(self,vx,vy,vz) -> None:
+                self.dim = 3
+                self.ndir = 7
+                self.nq_dir = math.ceil(np.log2(self.ndir))
+                self.dirs=[]
+                for dir_int in range(self.ndir):
+                    if dir_int==4:
+                        dir_bin="111"
+                    else:
+                        dir_bin = f"{dir_int:b}".zfill(self.nq_dir)
+                    self.dirs.append(dir_bin)
+                self.cs = 1/np.sqrt(3)
+                self.ux = lambda x,y,z: vx(x,y,z)/self.cs**2
+                self.uy = lambda x,y,z: vy(x,y,z)/self.cs**2
+                self.uz = lambda x,y,z: vz(x,y,z)/self.cs**2
+                self.create_circuit()
+
+            def create_circuit(self):
+                print("Creating circuit")
+                x_coeffs,x_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.ux(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                y_coeffs,y_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.uy(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                z_coeffs,z_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.uz(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                x_coeffs_,x_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.ux((x-1)/current_N,y/current_N,z/current_N))==0 else \
+                                        ((1+self.ux((x-1)/current_N,y/current_N,z/current_N))/(2+self.ux((x-1)/current_N,y/current_N,z/current_N)-self.ux((x+1)/current_N,y/current_N,z/current_N)))**0.5,num_reg_qubits,min(current_N,32))
+                y_coeffs_,y_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.uy(x/current_N,(y-1)/current_N,z/current_N))==0 else \
+                                        ((1+self.uy(x/current_N,(y-1)/current_N,z/current_N))/(2+self.uy(x/current_N,(y-1)/current_N,z/current_N)-self.uy(x/current_N,(y+1)/current_N,z/current_N)))**0.5,num_reg_qubits,min(current_N,32))
+                z_coeffs_,z_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.uz(x/current_N,y/current_N,(z-1)/current_N))==0 else \
+                                        ((1+self.uz(x/current_N,y/current_N,(z-1)/current_N))/(2+self.uz(x/current_N,y/current_N,(z-1)/current_N)-self.uz(x/current_N,y/current_N,(z+1)/current_N)))**0.5,num_reg_qubits,min(current_N,32))
+                unprep1_coeffs,unprep1_coeff_var_indices=get_circuit_inputs(lambda x,y,z:\
+                                        (1/3**0.5)*(1+(self.ux((x-1)/current_N,y/current_N,z/current_N)-self.ux((x+1)/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                unprep2_coeffs, unprep2_coeff_var_indices = get_circuit_inputs(lambda x, y, z: ((1 + (self.uy(x/current_N, (y-1)/current_N, z/current_N) - self.uy(x/current_N, (y+1)/current_N, z/current_N))/2) /(2 - (self.ux((x-1)/current_N, y/current_N, z/current_N) - self.ux((x+1)/current_N, y/current_N, z/current_N))/2))**0.5, num_reg_qubits, min(current_N, 32))
+                print("Generated angles")
+                v=np.pad([1/4, 1/4, 0, 1/4, 0, 1/4, 0],(0,2**num_anc - self.ndir))
+                v=v**0.5
+                v[0]+=1
+                v=v/np.linalg.norm(v)
+                U_prep=2*np.outer(v,v)-np.eye(len(v))
+                cudaq.register_operation("prep_op", U_prep)
+                def collisionOp(dirs):
+                    dirs_i_list=[]
+                    for dir_ in dirs:
+                        dirs_i=[(int(c)) for c in dir_]
+                        dirs_i_list+=dirs_i[::-1]
+                    return dirs_i_list
+                self.dirs_i_list=collisionOp(self.dirs)
+                print("Generated dirs_i_list")
+                @cudaq.kernel
+                def rshift(q: cudaq.qview, n: int):
+                    for i in range(n):
+                        if i == n-1:
+                            x(q[n-1-i])
+                        elif i == n-2:
+                            x.ctrl(q[n-1-(i+1)], q[n-1-i])
+                        else:
+                            x.ctrl(q[0:n-1-i], q[n-1-i])
+                @cudaq.kernel
+                def lshift(q: cudaq.qview, n: int):
+                    for i in range(n):
+                        if i == 0:
+                            x(q[0])
+                        elif i == 1:
+                            x.ctrl(q[0], q[1])
+                        else:
+                            x.ctrl(q[0:i], q[i])
+                @cudaq.kernel
+                def d2q5_tstep(q: cudaq.qview, nqx: int, nqy: int, nqz: int, nq_dir: int, dirs_i: list[int]):
+                    qx=q[0:nqx]
+                    qy=q[nqx:nqx+nqy]
+                    qz=q[nqx+nqy:nqx+nqy+nqz]
+                    qdir=q[nqx+nqy+nqz:nqx+nqy+nqz+nq_dir]
+                    i=2
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(lshift,qdir,qx,nqx)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=1
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(rshift,qdir,qx,nqx)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=4
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(lshift,qdir,qy,nqy)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=3
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(rshift,qdir,qy,nqy)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=6
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(lshift,qdir,qz,nqz)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=5
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(rshift,qdir,qz,nqz)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                @cudaq.kernel
+                def d2q5_tstep_wrapper(state: cudaq.State,nqx:int,nqy:int,nqz:int,nq_dir:int,dirs_i:list[int],\
+                                    x_coeff_var_indices:list[int],x_coeffs:list[float],\
+                                    y_coeff_var_indices:list[int],y_coeffs:list[float],\
+                                    z_coeff_var_indices:list[int],z_coeffs:list[float],\
+                                    x_coeff_var_indices_:list[int],x_coeffs_:list[float],\
+                                    y_coeff_var_indices_:list[int],y_coeffs_:list[float],\
+                                    z_coeff_var_indices_:list[int],z_coeffs_:list[float],\
+                                    unprep1_coeff_var_indices:list[int],unprep1_coeffs:list[float],\
+                                    unprep2_coeff_var_indices:list[int],unprep2_coeffs:list[float]):
+                    q=cudaq.qvector(state)
+                    qdir=q[nqx+nqy+nqz:nqx+nqy+nqz+nq_dir]
+                    prep_op(qdir[2],qdir[1],qdir[0])
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    x(qdir[2])
+                    while ind<len(x_coeff_var_indices):
+                        tuple_length=x_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1, ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-x_coeff_var_indices[sub_ind]],qdir[0])
+                        ry.ctrl(-x_coeffs[coeff_ind],[qdir[2],qdir[1]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x(qdir[2])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(z_coeff_var_indices):
+                        tuple_length=z_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-z_coeff_var_indices[sub_ind]],qdir[0])
+                        ry.ctrl(-z_coeffs[coeff_ind],[qdir[2],qdir[1]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(y_coeff_var_indices):
+                        tuple_length=y_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-y_coeff_var_indices[sub_ind]],qdir[2])
+                        ry.ctrl(y_coeffs[coeff_ind],[qdir[0],qdir[1]],qdir[2])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    d2q5_tstep(q,nqx,nqy,nqz,nq_dir,dirs_i)
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(y_coeff_var_indices_):
+                        tuple_length=y_coeff_var_indices_[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-y_coeff_var_indices_[sub_ind]],qdir[2])
+                        ry.ctrl(-y_coeffs_[coeff_ind],[qdir[0],qdir[1]],qdir[2])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    x(qdir[2])
+                    while ind<len(x_coeff_var_indices_):
+                        tuple_length=x_coeff_var_indices_[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-x_coeff_var_indices_[sub_ind]],qdir[0])
+                        ry.ctrl(x_coeffs_[coeff_ind],[qdir[1],qdir[2]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x(qdir[2])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(z_coeff_var_indices_):
+                        tuple_length=z_coeff_var_indices_[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-z_coeff_var_indices_[sub_ind]],qdir[0])
+                        ry.ctrl(z_coeffs_[coeff_ind],[qdir[1],qdir[2]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    x.ctrl(qdir[1],qdir[2])
+                    while ind<len(unprep2_coeff_var_indices):
+                        tuple_length=unprep2_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-unprep2_coeff_var_indices[sub_ind]],qdir[1])
+                        ry.ctrl(unprep2_coeffs[coeff_ind],qdir[2],qdir[1])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[1],qdir[2])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(unprep1_coeff_var_indices):
+                        tuple_length=unprep1_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-unprep1_coeff_var_indices[sub_ind]],qdir[1])
+                        ry.ctrl(-unprep1_coeffs[coeff_ind],qdir[0],qdir[1])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    ry(-2*np.pi/3,qdir[0])
+                print("Kernels defined")
+                def run_timestep_func(vec_arg, hadamard=False):
+                    result=cudaq.get_state(d2q5_tstep_wrapper,vec_arg,num_reg_qubits,num_reg_qubits,num_reg_qubits,self.nq_dir,self.dirs_i_list,\
+                                            x_coeff_var_indices,x_coeffs,\
+                                            y_coeff_var_indices,y_coeffs,\
+                                            z_coeff_var_indices,z_coeffs,\
+                                            x_coeff_var_indices_,x_coeffs_,\
+                                            y_coeff_var_indices_,y_coeffs_,\
+                                            z_coeff_var_indices_,z_coeffs_,\
+                                            unprep1_coeff_var_indices,unprep1_coeffs,\
+                                            unprep2_coeff_var_indices,unprep2_coeffs)
+                    num_nonzero_ranks = num_ranks / (2**num_anc)
+                    rank_slice_cupy = to_cupy_array(result)
+                    if rank >= num_nonzero_ranks and num_nonzero_ranks > 0:
+                        sub_sv_zeros = np.zeros(N_sub_per_rank, dtype=np.complex128)
+                        cp.cuda.runtime.memcpy(rank_slice_cupy.data.ptr, sub_sv_zeros.ctypes.data, sub_sv_zeros.nbytes, cp.cuda.runtime.memcpyHostToDevice)
+                    if rank == 0 and num_nonzero_ranks < 1 and N_sub_per_rank > 0:
+                        limit_idx = int(N_tot_state_vector / (2**num_anc))
+                        if limit_idx < rank_slice_cupy.size:
+                            rank_slice_cupy[limit_idx:] = 0
+                    return result
+                self.run_timestep = run_timestep_func
+            print("Circuit created")
+            def write_state(self, state_to_write, t_step_str_val):
+                rank_slice_cupy = to_cupy_array(state_to_write)
+                num_nonzero_ranks = num_ranks / (2**num_anc)
+                if rank < num_nonzero_ranks or (rank == 0 and num_nonzero_ranks <= 0):
+                    save_path = intermediate_folder_path / f"{t_step_str_val}_{rank}.npy"
+                    with open(save_path, 'wb') as f:
+                        arr_to_save = None
+                        data_limit = N_sub_per_rank
+                        if num_nonzero_ranks < 1 and rank == 0:
+                            data_limit = int(N_tot_state_vector / (2**num_anc))
+                        if data_limit > 0:
+                            relevant_part_cupy = cp.real(rank_slice_cupy[:data_limit])
+                        else:
+                            relevant_part_cupy = cp.array([], dtype=cp.float64)
+                        if relevant_part_cupy.size >= current_N * current_N * current_N:
+                            arr_flat = relevant_part_cupy[:current_N * current_N * current_N]
+                            if downsampling_factor > 1 and current_N > 0:
+                                arr_reshaped = arr_flat.reshape((current_N, current_N, current_N))
+                                arr_downsampled = arr_reshaped[::downsampling_factor, ::downsampling_factor, ::downsampling_factor]
+                                arr_to_save = arr_downsampled.flatten()
+                            else:
+                                arr_to_save = arr_flat
+                        elif relevant_part_cupy.size > 0:
+                            if downsampling_factor > 1:
+                                arr_to_save = relevant_part_cupy[::downsampling_factor]
+                            else:
+                                arr_to_save = relevant_part_cupy
+                        if arr_to_save is not None and arr_to_save.size > 0:
+                            np.save(f, arr_to_save.get() if isinstance(arr_to_save, cp.ndarray) else arr_to_save)
+            print("Write state defined")
+            def run_evolution(self, initial_state_arg, total_timesteps, time_steps_to_save, observable=False):
+                current_state_val = initial_state_arg
+                save_times = set(time_steps_to_save)
+                if 0 in save_times:
+                    print("Writing first state")
+                    self.write_state(current_state_val, '0')
+                for t_iter in range(total_timesteps):
+                    print("Running timestep")
+                    next_state_val = self.run_timestep(current_state_val)
+                    if (t_iter + 1) in save_times:
+                        print("Writing next state")
+                        self.write_state(next_state_val, str(t_iter + 1))
+                    cp.get_default_memory_pool().free_all_blocks()
+                    current_state_val = next_state_val
+                if rank == 0:
+                    print(f"Timestep: {total_timesteps}/{total_timesteps} (Evolution complete)")
+                cp.get_default_memory_pool().free_all_blocks()
+                self.final_state = current_state_val
+
+        if boundary_condition == "Periodic":
+            pass
+        elif boundary_condition == "Dirichlet":
+            pass
+        elif boundary_condition == "Neumann":
+            pass
+
+        downsampling_factor = 1
+        if current_N == 0:
+            print("Error: current_N is zero. num_reg_qubits likely too small.")
+            return None, None # Modified return
+        if current_N < downsampling_factor:
+            downsampling_factor = current_N if current_N > 0 else 1
+
+        qlbm_obj = QLBMAdvecDiffD3Q7_new(vx=vx_input, vy=vy_input, vz=vz_input)
+        initial_state_val = cudaq.get_state(alloc_kernel, num_qubits_total)
+
+        sub_sv_init_flat = initial_state_func_eval(np.arange(N_sub_per_rank)).astype(np.complex128)
+
+        norm = np.linalg.norm(sub_sv_init_flat)
+        if norm > 0:
+            sub_sv_init_flat /= norm
+        else:
+            print("Error: Initial state norm is zero.")
+            return None, None # Modified return
+        full_initial_sv_host = np.zeros(N_sub_per_rank, dtype=np.complex128)
+        num_computational_states = current_N ** 3
+        if len(sub_sv_init_flat) == num_computational_states:
+            if num_computational_states <= N_sub_per_rank:
+                full_initial_sv_host[:num_computational_states] = sub_sv_init_flat
+            else:
+                print(f"Error: Grid data {num_computational_states} > N_sub_per_rank {N_sub_per_rank}")
+                return None, None # Modified return
+        else:
+            print(f"Warning: Initial state size {len(sub_sv_init_flat)} != expected {num_computational_states}")
+            fill_len = min(len(sub_sv_init_flat), num_computational_states, N_sub_per_rank)
+            full_initial_sv_host[:fill_len] = sub_sv_init_flat[:fill_len]
+
+        rank_slice_init = to_cupy_array(initial_state_val)
+        print(f'Rank {rank}: Initializing state with {distribution_type} (vx={vx_input}, vy={vy_input})...')
+        cp.cuda.runtime.memcpy(rank_slice_init.data.ptr, full_initial_sv_host.ctypes.data, full_initial_sv_host.nbytes, cp.cuda.runtime.memcpyHostToDevice)
+        print(f'Rank {rank}: Initial state copied. Size: {len(sub_sv_init_flat)}. N_sub_per_rank: {N_sub_per_rank}')
+
+        print("Starting QLBM evolution...")
+        qlbm_obj.run_evolution(initial_state_val, T, time_steps)
+        print("QLBM evolution complete.")
+
+        print("Generating interactive plot with Plotly...")
+        downsampled_N = current_N // downsampling_factor
+        if downsampled_N == 0 and current_N > 0:
+            downsampled_N = 1
+        elif current_N == 0:
+            print("Error: current_N is zero before Plotly stage.")
+            return None, None # Modified return
+
+        data_frames = []
+        actual_timesteps = []
+        for t in time_steps:
+            file_path = intermediate_folder_path / f"{t}_{rank}.npy"
+            if file_path.exists():
+                sol_loaded = np.load(file_path)
+                if sol_loaded.size == downsampled_N * downsampled_N* downsampled_N:
+                    data = np.reshape(sol_loaded, (downsampled_N, downsampled_N, downsampled_N))
+                    data_frames.append(data)
+                    actual_timesteps.append(t)
+                    print(f"Time {t}: Min={np.min(data)}, Max={np.max(data)}, Mean={np.mean(data)}")
+                else:
+                    print(f"Warning: File {file_path} size {sol_loaded.size} != expected {downsampled_N*downsampled_N*downsampled_N}. Skipping.")
+            else:
+                print(f"Warning: File {file_path} not found. Skipping.")
+
+        if not data_frames:
+            print("Error: No data frames loaded for plotting.")
+            return None, None # Modified return
+
+        x_coords_plot = np.linspace(0, 1, downsampled_N)
+        y_coords_plot = np.linspace(0, 1, downsampled_N)
+        z_coords_plot = np.linspace(0, 1, downsampled_N)
+        Z_grid_mesh, Y_grid_mesh, X_grid_mesh = np.meshgrid(x_coords_plot, y_coords_plot, z_coords_plot, indexing='ij')
+
+        data_min = min([np.min(data) for data in data_frames])
+        data_max = max([np.max(data) for data in data_frames])
+        if data_max == data_min:
+            data_max += 1e-9
+
+        fig = go.Figure()
+
+        # Store individual frames for download
+        plotly_json_frames = []
+
+        for i, output_data in enumerate(data_frames):
+            frame_trace = go.Isosurface(
+                x=X_grid_mesh.flatten(),
+                y=Y_grid_mesh.flatten(),
+                z=Z_grid_mesh.flatten(),
+                value=output_data.flatten(),
+                isomin=data_min,
+                isomax=data_max,
+                opacity=0.4, # needs to be small to see through all surfaces
+                surface_count=7, # needs to be a large number for good volume rendering,
+                caps=dict(x_show=False, y_show=False, z_show=False)
+            )
+            fig.add_trace(frame_trace)
+
+            # Create a figure for the individual frame and convert to JSON
+            single_frame_fig = go.Figure(data=[frame_trace], layout=fig.layout)
+            single_frame_fig.update_layout(
+                title=f"Time: {actual_timesteps[i]}",
+                scene=dict(
+                    xaxis_title='X',
+                    yaxis_title='Y',
+                    zaxis_title='Z',
+                    xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+                    yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+                    zaxis=dict(range=[z_coords_plot[0], z_coords_plot[-1]]),
+                )
+            )
+            plotly_json_frames.append(single_frame_fig.to_json())
+
+        for trace in fig.data[1:]:
+            trace.visible = False
+
+        steps = []
+        for i in range(len(data_frames)):
+            step = dict(
+                method="update",
+                args=[{"visible": [False] * len(data_frames)}],
+                label=f"Time: {actual_timesteps[i]}"
+            )
+            step["args"][0]["visible"][i] = True
+            steps.append(step)
+
+        sliders = [dict(active=0, currentvalue={"prefix": "Time: "}, pad={"t": 50}, steps=steps)]
+
+        fig.update_layout(
+            title='',  # Removed graph title
+            scene=dict(
+                xaxis_title='X',
+                yaxis_title='Y',
+                zaxis_title='Z',
+                xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+                yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+                zaxis=dict(range=[z_coords_plot[0], z_coords_plot[-1]]),
+            ),
+            sliders=sliders,
+            width=800,
+            height=700
+        )
+
+        return fig, plotly_json_frames # Modified return

fluid3d_pyvista.py

@@ -0,0 +1,638 @@
+import os
+import math
+import tempfile
+import cudaq
+import numpy as np
+import cupy as cp
+from pathlib import Path
+import plotly.graph_objects as go
+import plotly.io as pio
+
+# Set Plotly engine for image export
+try:
+    pio.kaleido.scope.mathjax = None
+except AttributeError:
+    pass
+
+# Existing functions (bin_to_gray, gray_to_bin, etc.) remain unchanged
+def bin_to_gray(bin_s):
+    XOR=lambda x,y: (x or y) and not (x and y)
+    gray_s=bin_s[0]
+    for i in range(len(bin_s)-1):
+        c_bool=XOR(bool(int(bin_s[i])),bool(int(bin_s[i+1])))
+        gray_s+=str(int(c_bool))
+    return gray_s
+
+def gray_to_bin(gray_s):
+  XOR=lambda x,y: (x or y) and not (x and y)
+  bin_s=gray_s[0]
+  for i in range(len(gray_s)-1):
+    c_bool=XOR(bool(int(bin_s[i])),bool(int(gray_s[i+1])))
+    bin_s+=str(int(c_bool))
+  return bin_s
+
+def bin_to_int(bin_s):
+  return int(bin_s,2)
+
+def int_to_bin(i,pad):
+  return bin(i)[2:].zfill(pad)
+
+def fwht_approx(f,N,num_points_per_dim,threshold=1e-10):
+  linear_block_size=int(N//num_points_per_dim)
+  num_angles_per_block=int(np.log2(linear_block_size))
+
+  thetas={}
+
+  for k in range(num_points_per_dim):
+    for j in range(num_points_per_dim):
+      for i in range(num_points_per_dim):
+
+        avg_f=2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2))
+        thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size]=avg_f
+
+        slope_x=(2*np.arccos(f(i*linear_block_size,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2))-2*np.arccos(f(((i+1)%N)*linear_block_size,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2)))/linear_block_size
+        slope_y=(2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size,k*linear_block_size+(linear_block_size-1)/2))-2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,((j+1)%N)*linear_block_size,k*linear_block_size+(linear_block_size-1)/2)))/linear_block_size
+        slope_z=(2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size))-2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,((k+1)%N)*linear_block_size)))/linear_block_size
+
+        for m in range(num_angles_per_block):
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + 2**m]=slope_x*(2**(m-1))
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + N*(2**m)]=slope_y*(2**(m-1))
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + (N**2)*(2**m)]=slope_z*(2**(m-1))
+
+  h = linear_block_size
+  while h < N**3:
+    for i in range(0, N**3, h * 2):
+      if (i//N)%linear_block_size!=0:
+        continue
+      if (i//(N**2))%linear_block_size!=0:
+        continue
+      j=i
+      while j<i+h:
+        index=j
+        x = thetas[index]
+        y = thetas[index + h]
+        thetas[index] = (x + y)/2
+        thetas[index + h] = (x - y)/2
+
+        for ax in range(3):
+          for m in range(num_angles_per_block):
+            index = j + (N**ax) * (2**m)
+            x = thetas[index]
+            y = thetas[index + h]
+            thetas[index] = (x + y)/2
+            thetas[index + h] = (x - y)/2
+
+        j+=linear_block_size
+        if (j//N)%linear_block_size==1:
+          j+=(linear_block_size-1)*N
+        if (j//(N**2))%linear_block_size==1:
+          j+=(linear_block_size-1)*(N**2)
+
+    h *= 2
+    if h==N:
+      h=N*linear_block_size
+    if h==N**2:
+      h=(N**2)*linear_block_size
+
+  return [theta for theta in thetas.values() if abs(theta)>threshold],[key for key in thetas.keys() if abs(thetas[key])>threshold]
+
+def get_circuit_inputs(f,num_reg_qubits,num_points_per_dim):
+  theta_vec,indices=fwht_approx(f,2**num_reg_qubits,num_points_per_dim)
+  circ_pos=[]
+  for ind in indices:
+    circ_pos+=[bin_to_int(gray_to_bin(int_to_bin(ind,num_reg_qubits*3)))]
+
+  sorted_theta_vec=sorted(zip(theta_vec,circ_pos),key=lambda el:el[1])
+  ctrls=[]
+
+  current_bs="0"*(3*num_reg_qubits)
+  for el in sorted_theta_vec:
+    new_bs=bin_to_gray(int_to_bin((el[1])%(2**(3*num_reg_qubits)),(3*num_reg_qubits)))
+    ctrls += [[i for i, (char1, char2) in enumerate(zip(current_bs, new_bs)) if char1 != char2]]
+    current_bs=new_bs
+  new_bs="0"*(3*num_reg_qubits)
+  ctrls += [[i for i, (char1, char2) in enumerate(zip(current_bs, new_bs)) if char1 != char2]]
+
+  ctrls_flat_list=[]
+  for ctrl_list in ctrls:
+    ctrls_flat_list+=[len(ctrl_list)]+ctrl_list
+
+  return [el[0] for el in sorted_theta_vec]+[0.0],ctrls_flat_list
+
+def simulate_qlbm_3D_and_animate(num_reg_qubits: int, T: int, distribution_type: str, vx_input, vy_input, vz_input, boundary_condition: str):
+    num_anc = 3
+    num_qubits_total = 3 * num_reg_qubits + num_anc
+    current_N = 2**num_reg_qubits
+    N_tot_state_vector = 2**num_qubits_total
+    num_ranks = 1
+    rank = 0
+    N_sub_per_rank = int(N_tot_state_vector // num_ranks)
+
+    # Simplified time steps for 3D since slider steps are removed
+    NUM_ANIMATION_FRAMES_3D = 10 # Default number of frames if no specific slider steps
+
+    if T == 0:
+        time_steps = [0]
+    else:
+        num_points = min(T + 1, NUM_ANIMATION_FRAMES_3D)
+        time_steps = np.linspace(start=0, stop=T, num=num_points, dtype=int)
+        time_steps = sorted(list(set(time_steps)))
+
+
+    if distribution_type == "Sinusoidal":
+        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
+            np.sin(x * 2 * np.pi / N_val_func) * \
+            np.sin(y * 2 * np.pi / N_val_func) * \
+            np.sin(z * 2 * np.pi / N_val_func) + 1
+    elif distribution_type == "Gaussian":
+        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
+            np.exp(-((x - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) + (y - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2) +
+                     (z - N_val_func / 2)**2 / (2 * (N_val_func / 5)**2))) * 1.8 + 0.2
+    else:
+        print(f"Warning: Unknown distribution type '{distribution_type}'. Defaulting to Sinusoidal.")
+        selected_initial_state_function_raw = lambda x, y, z, N_val_func: \
+            np.sin(x * 2 * np.pi / N_val_func) * \
+            np.sin(y * 2 * np.pi / N_val_func) * \
+            np.sin(z * 2 * np.pi / N_val_func) + 1
+
+    initial_state_func_eval = lambda i:\
+        selected_initial_state_function_raw(i%current_N,(i//current_N)%current_N,i//(current_N**2),current_N)*(i<(current_N**3)).astype(int)
+
+    with tempfile.TemporaryDirectory() as tmp_npy_dir:
+        intermediate_folder_path = Path(tmp_npy_dir)
+
+        cudaq.set_target('nvidia', option='fp64')
+
+        @cudaq.kernel
+        def alloc_kernel(num_qubits_alloc: int):
+            qubits = cudaq.qvector(num_qubits_alloc)
+
+        from cupy.cuda.memory import MemoryPointer, UnownedMemory
+
+        def to_cupy_array(state):
+            tensor = state.getTensor()
+            pDevice = tensor.data()
+            sizeByte = tensor.get_num_elements() * tensor.get_element_size()
+            mem = UnownedMemory(pDevice, sizeByte, owner=state)
+            memptr_obj = MemoryPointer(mem, 0)
+            cupy_array_val = cp.ndarray(tensor.get_num_elements(),
+                                      dtype=cp.complex128,
+                                      memptr=memptr_obj)
+            return cupy_array_val
+
+        class QLBMAdvecDiffD3Q7_new:
+            def __init__(self,vx,vy,vz) -> None:
+                self.dim = 3
+                self.ndir = 7
+                self.nq_dir = math.ceil(np.log2(self.ndir))
+                self.dirs=[]
+                for dir_int in range(self.ndir):
+                    if dir_int==4:
+                        dir_bin="111"
+                    else:
+                        dir_bin = f"{dir_int:b}".zfill(self.nq_dir)
+                    self.dirs.append(dir_bin)
+                self.cs = 1/np.sqrt(3)
+                self.ux = lambda x,y,z: vx(x,y,z)/self.cs**2
+                self.uy = lambda x,y,z: vy(x,y,z)/self.cs**2
+                self.uz = lambda x,y,z: vz(x,y,z)/self.cs**2
+                self.create_circuit()
+
+            def create_circuit(self):
+                print("Creating circuit")
+                x_coeffs,x_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.ux(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                y_coeffs,y_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.uy(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                z_coeffs,z_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+self.uz(x/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                x_coeffs_,x_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.ux((x-1)/current_N,y/current_N,z/current_N))==0 else \
+                                        ((1+self.ux((x-1)/current_N,y/current_N,z/current_N))/(2+self.ux((x-1)/current_N,y/current_N,z/current_N)-self.ux((x+1)/current_N,y/current_N,z/current_N)))**0.5,num_reg_qubits,min(current_N,32))
+                y_coeffs_,y_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.uy(x/current_N,(y-1)/current_N,z/current_N))==0 else \
+                                        ((1+self.uy(x/current_N,(y-1)/current_N,z/current_N))/(2+self.uy(x/current_N,(y-1)/current_N,z/current_N)-self.uy(x/current_N,(y+1)/current_N,z/current_N)))**0.5,num_reg_qubits,min(current_N,32))
+                z_coeffs_,z_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+self.uz(x/current_N,y/current_N,(z-1)/current_N))==0 else \
+                                        ((1+self.uz(x/current_N,y/current_N,(z-1)/current_N))/(2+self.uz(x/current_N,y/current_N,(z-1)/current_N)-self.uz(x/current_N,y/current_N,(z+1)/current_N)))**0.5,num_reg_qubits,min(current_N,32))
+                unprep1_coeffs,unprep1_coeff_var_indices=get_circuit_inputs(lambda x,y,z:\
+                                        (1/3**0.5)*(1+(self.ux((x-1)/current_N,y/current_N,z/current_N)-self.ux((x+1)/current_N,y/current_N,z/current_N))/2)**0.5,num_reg_qubits,min(current_N,32))
+                unprep2_coeffs, unprep2_coeff_var_indices = get_circuit_inputs(lambda x, y, z: ((1 + (self.uy(x/current_N, (y-1)/current_N, z/current_N) - self.uy(x/current_N, (y+1)/current_N, z/current_N))/2) /(2 - (self.ux((x-1)/current_N, y/current_N, z/current_N) - self.ux((x+1)/current_N, y/current_N, z/current_N))/2))**0.5, num_reg_qubits, min(current_N, 32))
+                print("Generated angles")
+                v=np.pad([1/4, 1/4, 0, 1/4, 0, 1/4, 0],(0,2**num_anc - self.ndir))
+                v=v**0.5
+                v[0]+=1
+                v=v/np.linalg.norm(v)
+                U_prep=2*np.outer(v,v)-np.eye(len(v))
+                cudaq.register_operation("prep_op", U_prep)
+                def collisionOp(dirs):
+                    dirs_i_list=[]
+                    for dir_ in dirs:
+                        dirs_i=[(int(c)) for c in dir_]
+                        dirs_i_list+=dirs_i[::-1]
+                    return dirs_i_list
+                self.dirs_i_list=collisionOp(self.dirs)
+                print("Generated dirs_i_list")
+                @cudaq.kernel
+                def rshift(q: cudaq.qview, n: int):
+                    for i in range(n):
+                        if i == n-1:
+                            x(q[n-1-i])
+                        elif i == n-2:
+                            x.ctrl(q[n-1-(i+1)], q[n-1-i])
+                        else:
+                            x.ctrl(q[0:n-1-i], q[n-1-i])
+                @cudaq.kernel
+                def lshift(q: cudaq.qview, n: int):
+                    for i in range(n):
+                        if i == 0:
+                            x(q[0])
+                        elif i == 1:
+                            x.ctrl(q[0], q[1])
+                        else:
+                            x.ctrl(q[0:i], q[i])
+                @cudaq.kernel
+                def d2q5_tstep(q: cudaq.qview, nqx: int, nqy: int, nqz: int, nq_dir: int, dirs_i: list[int]):
+                    qx=q[0:nqx]
+                    qy=q[nqx:nqx+nqy]
+                    qz=q[nqx+nqy:nqx+nqy+nqz]
+                    qdir=q[nqx+nqy+nqz:nqx+nqy+nqz+nq_dir]
+                    i=2
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(lshift,qdir,qx,nqx)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=1
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(rshift,qdir,qx,nqx)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=4
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(lshift,qdir,qy,nqy)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=3
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(rshift,qdir,qy,nqy)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=6
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(lshift,qdir,qz,nqz)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    i=5
+                    b_list=dirs_i[i*nq_dir:(i+1)*nq_dir]
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                    cudaq.control(rshift,qdir,qz,nqz)
+                    for j in range(nq_dir):
+                        b=b_list[j]
+                        if b==0:
+                            x(qdir[j])
+                @cudaq.kernel
+                def d2q5_tstep_wrapper(state: cudaq.State,nqx:int,nqy:int,nqz:int,nq_dir:int,dirs_i:list[int],\
+                                    x_coeff_var_indices:list[int],x_coeffs:list[float],\
+                                    y_coeff_var_indices:list[int],y_coeffs:list[float],\
+                                    z_coeff_var_indices:list[int],z_coeffs:list[float],\
+                                    x_coeff_var_indices_:list[int],x_coeffs_:list[float],\
+                                    y_coeff_var_indices_:list[int],y_coeffs_:list[float],\
+                                    z_coeff_var_indices_:list[int],z_coeffs_:list[float],\
+                                    unprep1_coeff_var_indices:list[int],unprep1_coeffs:list[float],\
+                                    unprep2_coeff_var_indices:list[int],unprep2_coeffs:list[float]):
+                    q=cudaq.qvector(state)
+                    qdir=q[nqx+nqy+nqz:nqx+nqy+nqz+nq_dir]
+                    prep_op(qdir[2],qdir[1],qdir[0])
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    x(qdir[2])
+                    while ind<len(x_coeff_var_indices):
+                        tuple_length=x_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1, ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-x_coeff_var_indices[sub_ind]],qdir[0])
+                        ry.ctrl(-x_coeffs[coeff_ind],[qdir[2],qdir[1]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x(qdir[2])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(z_coeff_var_indices):
+                        tuple_length=z_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-z_coeff_var_indices[sub_ind]],qdir[0])
+                        ry.ctrl(-z_coeffs[coeff_ind],[qdir[2],qdir[1]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(y_coeff_var_indices):
+                        tuple_length=y_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-y_coeff_var_indices[sub_ind]],qdir[2])
+                        ry.ctrl(y_coeffs[coeff_ind],[qdir[0],qdir[1]],qdir[2])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    d2q5_tstep(q,nqx,nqy,nqz,nq_dir,dirs_i)
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(y_coeff_var_indices_):
+                        tuple_length=y_coeff_var_indices_[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-y_coeff_var_indices_[sub_ind]],qdir[2])
+                        ry.ctrl(-y_coeffs_[coeff_ind],[qdir[0],qdir[1]],qdir[2])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    x(qdir[2])
+                    while ind<len(x_coeff_var_indices_):
+                        tuple_length=x_coeff_var_indices_[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-x_coeff_var_indices_[sub_ind]],qdir[0])
+                        ry.ctrl(x_coeffs_[coeff_ind],[qdir[1],qdir[2]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x(qdir[2])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(z_coeff_var_indices_):
+                        tuple_length=z_coeff_var_indices_[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-z_coeff_var_indices_[sub_ind]],qdir[0])
+                        ry.ctrl(z_coeffs_[coeff_ind],[qdir[1],qdir[2]],qdir[0])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[0],qdir[1])
+                    ind=0
+                    coeff_ind=0
+                    x.ctrl(qdir[1],qdir[2])
+                    while ind<len(unprep2_coeff_var_indices):
+                        tuple_length=unprep2_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-unprep2_coeff_var_indices[sub_ind]],qdir[1])
+                        ry.ctrl(unprep2_coeffs[coeff_ind],qdir[2],qdir[1])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    x.ctrl(qdir[1],qdir[2])
+                    ind=0
+                    coeff_ind=0
+                    while ind<len(unprep1_coeff_var_indices):
+                        tuple_length=unprep1_coeff_var_indices[ind]
+                        for sub_ind in range(ind+1,ind+1+tuple_length):
+                            x.ctrl(q[nqx+nqy+nqz-1-unprep1_coeff_var_indices[sub_ind]],qdir[1])
+                        ry.ctrl(-unprep1_coeffs[coeff_ind],qdir[0],qdir[1])
+                        coeff_ind+=1
+                        ind+=(1+tuple_length)
+                    ry(-2*np.pi/3,qdir[0])
+                print("Kernels defined")
+                def run_timestep_func(vec_arg, hadamard=False):
+                    result=cudaq.get_state(d2q5_tstep_wrapper,vec_arg,num_reg_qubits,num_reg_qubits,num_reg_qubits,self.nq_dir,self.dirs_i_list,\
+                                            x_coeff_var_indices,x_coeffs,\
+                                            y_coeff_var_indices,y_coeffs,\
+                                            z_coeff_var_indices,z_coeffs,\
+                                            x_coeff_var_indices_,x_coeffs_,\
+                                            y_coeff_var_indices_,y_coeffs_,\
+                                            z_coeff_var_indices_,z_coeffs_,\
+                                            unprep1_coeff_var_indices,unprep1_coeffs,\
+                                            unprep2_coeff_var_indices,unprep2_coeffs)
+                    num_nonzero_ranks = num_ranks / (2**num_anc)
+                    rank_slice_cupy = to_cupy_array(result)
+                    if rank >= num_nonzero_ranks and num_nonzero_ranks > 0:
+                        sub_sv_zeros = np.zeros(N_sub_per_rank, dtype=np.complex128)
+                        cp.cuda.runtime.memcpy(rank_slice_cupy.data.ptr, sub_sv_zeros.ctypes.data, sub_sv_zeros.nbytes, cp.cuda.runtime.memcpyHostToDevice)
+                    if rank == 0 and num_nonzero_ranks < 1 and N_sub_per_rank > 0:
+                        limit_idx = int(N_tot_state_vector / (2**num_anc))
+                        if limit_idx < rank_slice_cupy.size:
+                            rank_slice_cupy[limit_idx:] = 0
+                    return result
+                self.run_timestep = run_timestep_func
+            print("Circuit created")
+            def write_state(self, state_to_write, t_step_str_val):
+                rank_slice_cupy = to_cupy_array(state_to_write)
+                num_nonzero_ranks = num_ranks / (2**num_anc)
+                if rank < num_nonzero_ranks or (rank == 0 and num_nonzero_ranks <= 0):
+                    save_path = intermediate_folder_path / f"{t_step_str_val}_{rank}.npy"
+                    with open(save_path, 'wb') as f:
+                        arr_to_save = None
+                        data_limit = N_sub_per_rank
+                        if num_nonzero_ranks < 1 and rank == 0:
+                            data_limit = int(N_tot_state_vector / (2**num_anc))
+                        if data_limit > 0:
+                            relevant_part_cupy = cp.real(rank_slice_cupy[:data_limit])
+                        else:
+                            relevant_part_cupy = cp.array([], dtype=cp.float64)
+                        if relevant_part_cupy.size >= current_N * current_N * current_N:
+                            arr_flat = relevant_part_cupy[:current_N * current_N * current_N]
+                            if downsampling_factor > 1 and current_N > 0:
+                                arr_reshaped = arr_flat.reshape((current_N, current_N, current_N))
+                                arr_downsampled = arr_reshaped[::downsampling_factor, ::downsampling_factor, ::downsampling_factor]
+                                arr_to_save = arr_downsampled.flatten()
+                            else:
+                                arr_to_save = arr_flat
+                        elif relevant_part_cupy.size > 0:
+                            if downsampling_factor > 1:
+                                arr_to_save = relevant_part_cupy[::downsampling_factor]
+                            else:
+                                arr_to_save = relevant_part_cupy
+                        if arr_to_save is not None and arr_to_save.size > 0:
+                            np.save(f, arr_to_save.get() if isinstance(arr_to_save, cp.ndarray) else arr_to_save)
+            print("Write state defined")
+            def run_evolution(self, initial_state_arg, total_timesteps, time_steps_to_save, observable=False):
+                current_state_val = initial_state_arg
+                save_times = set(time_steps_to_save)
+                if 0 in save_times:
+                    print("Writing first state")
+                    self.write_state(current_state_val, '0')
+                for t_iter in range(total_timesteps):
+                    print("Running timestep")
+                    next_state_val = self.run_timestep(current_state_val)
+                    if (t_iter + 1) in save_times:
+                        print("Writing next state")
+                        self.write_state(next_state_val, str(t_iter + 1))
+                    cp.get_default_memory_pool().free_all_blocks()
+                    current_state_val = next_state_val
+                if rank == 0:
+                    print(f"Timestep: {total_timesteps}/{total_timesteps} (Evolution complete)")
+                cp.get_default_memory_pool().free_all_blocks()
+                self.final_state = current_state_val
+
+        if boundary_condition == "Periodic":
+            pass
+        elif boundary_condition == "Dirichlet":
+            pass
+        elif boundary_condition == "Neumann":
+            pass
+
+        downsampling_factor = 1
+        if current_N == 0:
+            print("Error: current_N is zero. num_reg_qubits likely too small.")
+            return None, None # Modified return
+        if current_N < downsampling_factor:
+            downsampling_factor = current_N if current_N > 0 else 1
+
+        qlbm_obj = QLBMAdvecDiffD3Q7_new(vx=vx_input, vy=vy_input, vz=vz_input)
+        initial_state_val = cudaq.get_state(alloc_kernel, num_qubits_total)
+
+        sub_sv_init_flat = initial_state_func_eval(np.arange(N_sub_per_rank)).astype(np.complex128)
+
+        norm = np.linalg.norm(sub_sv_init_flat)
+        if norm > 0:
+            sub_sv_init_flat /= norm
+        else:
+            print("Error: Initial state norm is zero.")
+            return None, None # Modified return
+        full_initial_sv_host = np.zeros(N_sub_per_rank, dtype=np.complex128)
+        num_computational_states = current_N ** 3
+        if len(sub_sv_init_flat) == num_computational_states:
+            if num_computational_states <= N_sub_per_rank:
+                full_initial_sv_host[:num_computational_states] = sub_sv_init_flat
+            else:
+                print(f"Error: Grid data {num_computational_states} > N_sub_per_rank {N_sub_per_rank}")
+                return None, None # Modified return
+        else:
+            print(f"Warning: Initial state size {len(sub_sv_init_flat)} != expected {num_computational_states}")
+            fill_len = min(len(sub_sv_init_flat), num_computational_states, N_sub_per_rank)
+            full_initial_sv_host[:fill_len] = sub_sv_init_flat[:fill_len]
+
+        rank_slice_init = to_cupy_array(initial_state_val)
+        print(f'Rank {rank}: Initializing state with {distribution_type} (vx={vx_input}, vy={vy_input})...')
+        cp.cuda.runtime.memcpy(rank_slice_init.data.ptr, full_initial_sv_host.ctypes.data, full_initial_sv_host.nbytes, cp.cuda.runtime.memcpyHostToDevice)
+        print(f'Rank {rank}: Initial state copied. Size: {len(sub_sv_init_flat)}. N_sub_per_rank: {N_sub_per_rank}')
+
+        print("Starting QLBM evolution...")
+        qlbm_obj.run_evolution(initial_state_val, T, time_steps)
+        print("QLBM evolution complete.")
+
+        print("Generating interactive plot with Plotly...")
+        downsampled_N = current_N // downsampling_factor
+        if downsampled_N == 0 and current_N > 0:
+            downsampled_N = 1
+        elif current_N == 0:
+            print("Error: current_N is zero before Plotly stage.")
+            return None, None # Modified return
+
+        data_frames = []
+        actual_timesteps = []
+        for t in time_steps:
+            file_path = intermediate_folder_path / f"{t}_{rank}.npy"
+            if file_path.exists():
+                sol_loaded = np.load(file_path)
+                if sol_loaded.size == downsampled_N * downsampled_N* downsampled_N:
+                    data = np.reshape(sol_loaded, (downsampled_N, downsampled_N, downsampled_N))
+                    data_frames.append(data)
+                    actual_timesteps.append(t)
+                    print(f"Time {t}: Min={np.min(data)}, Max={np.max(data)}, Mean={np.mean(data)}")
+                else:
+                    print(f"Warning: File {file_path} size {sol_loaded.size} != expected {downsampled_N*downsampled_N*downsampled_N}. Skipping.")
+            else:
+                print(f"Warning: File {file_path} not found. Skipping.")
+
+        if not data_frames:
+            print("Error: No data frames loaded for plotting.")
+            return None, None # Modified return
+
+        x_coords_plot = np.linspace(0, 1, downsampled_N)
+        y_coords_plot = np.linspace(0, 1, downsampled_N)
+        z_coords_plot = np.linspace(0, 1, downsampled_N)
+        Z_grid_mesh, Y_grid_mesh, X_grid_mesh = np.meshgrid(x_coords_plot, y_coords_plot, z_coords_plot, indexing='ij')
+
+        data_min = min([np.min(data) for data in data_frames])
+        data_max = max([np.max(data) for data in data_frames])
+        if data_max == data_min:
+            data_max += 1e-9
+
+        fig = go.Figure()
+
+        # Store individual frames for download
+        plotly_json_frames = []
+
+        for i, output_data in enumerate(data_frames):
+            frame_trace = go.Isosurface(
+                x=X_grid_mesh.flatten(),
+                y=Y_grid_mesh.flatten(),
+                z=Z_grid_mesh.flatten(),
+                value=output_data.flatten(),
+                isomin=data_min,
+                isomax=data_max,
+                opacity=0.4, # needs to be small to see through all surfaces
+                surface_count=7, # needs to be a large number for good volume rendering,
+                caps=dict(x_show=False, y_show=False, z_show=False)
+            )
+            fig.add_trace(frame_trace)
+
+            # Create a figure for the individual frame and convert to JSON
+            single_frame_fig = go.Figure(data=[frame_trace], layout=fig.layout)
+            single_frame_fig.update_layout(
+                title=f"Time: {actual_timesteps[i]}",
+                scene=dict(
+                    xaxis_title='X',
+                    yaxis_title='Y',
+                    zaxis_title='Z',
+                    xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+                    yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+                    zaxis=dict(range=[z_coords_plot[0], z_coords_plot[-1]]),
+                )
+            )
+            plotly_json_frames.append(single_frame_fig.to_json())
+
+        for trace in fig.data[1:]:
+            trace.visible = False
+
+        steps = []
+        for i in range(len(data_frames)):
+            step = dict(
+                method="update",
+                args=[{"visible": [False] * len(data_frames)}],
+                label=f"Time: {actual_timesteps[i]}"
+            )
+            step["args"][0]["visible"][i] = True
+            steps.append(step)
+
+        sliders = [dict(active=0, currentvalue={"prefix": "Time: "}, pad={"t": 50}, steps=steps)]
+
+        fig.update_layout(
+            title='',  # Removed graph title
+            scene=dict(
+                xaxis_title='X',
+                yaxis_title='Y',
+                zaxis_title='Z',
+                xaxis=dict(range=[x_coords_plot[0], x_coords_plot[-1]]),
+                yaxis=dict(range=[y_coords_plot[0], y_coords_plot[-1]]),
+                zaxis=dict(range=[z_coords_plot[0], z_coords_plot[-1]]),
+            ),
+            sliders=sliders,
+            width=800,
+            height=700
+        )
+
+        return fig, plotly_json_frames # Modified return

pages/em_page.py

@@ -7,6 +7,7 @@ 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")
 
 
 def _kill_em_process():
@@ -38,6 +39,7 @@ def _ensure_em_process_started():
     env = os.environ.copy()
     # 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)
@@ -51,9 +53,10 @@ 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)
     with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
         trame_html.Iframe(
-            src=("em_iframe_src", f"http://localhost:{port}/"),
+            src=("em_iframe_src", f"http://{host}:{port}/"),
             style="border:0; width:100%; height: calc(100vh - 64px);",
         )
         trame_html.Div(

pages/qlbm_page.py

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

qlbm.py

@@ -1,613 +1,669 @@
+"""trame3d.py
+An equivalent Trame application replicating the functionality of `gradio3d.py`.
+
+Features ported from Gradio version:
+ - Example initial distributions (Sinusoidal / Gaussian) with buttons to load presets
+ - Simulation parameter controls (grid size slider, time steps slider)
+ - Dynamic qubit requirement plot vs. grid size (log2 relation)
+ - Velocity field presets (Uniform / Swirl / Shear / TGV) updating velocity expression text boxes
+ - Custom velocity expression inputs parsed via SymPy (x, y, z)
+ - Initial distribution type radio (Gaussian / Sinusoidal)
+ - Boundary condition radio (Periodic / Dirichlet / Neumann)
+ - Run simulation button producing a mock 3D Plotly scatter visualization
+ - Download JSON frames button (zip of Plotly figure JSON) enabled post-run
+
+This is a standalone Trame app and can also be embedded via the `build(host_server)` helper.
+"""
+
 import os
-import numpy as np
 import math
+import tempfile
+import zipfile
+import numpy as np
+import plotly.graph_objects as go
+import importlib
+import sys
+import types
+import time
+import multiprocessing as mp
+import plotly.io as pio
+symbols = sympify = lambdify = None  # Deferred SymPy import handled at runtime
+
 from trame.app import get_server
 from trame_vuetify.ui.vuetify3 import SinglePageLayout
 from trame_vuetify.widgets import vuetify3
 from trame.widgets import html as trame_html
 from trame_plotly.widgets import plotly as plotly_widgets
-import plotly.graph_objects as go
-
-# --- Server and State ---
-server = get_server(name="qlbm")  # kept for standalone use; embedding will rebind to host server
+ 
+
+# Local simulation module (lazy with optional shim for gradio_litmodel3d)
+qfluid = None
+
+def _ensure_qfluid_import():
+	"""Attempt to import fluid.py as qfluid.
+	If gradio_litmodel3d is missing, temporarily stub it to avoid import failure.
+	Return imported module or None.
+	"""
+	global qfluid
+	if qfluid is not None:
+		return qfluid
+	# Try plain import first
+	try:
+		import fluid as _qf
+		qfluid = _qf
+		return qfluid
+	except Exception:
+		pass
+	# Retry with a lightweight stub for gradio_litmodel3d
+	if 'gradio_litmodel3d' not in sys.modules:
+		sys.modules['gradio_litmodel3d'] = types.ModuleType('gradio_litmodel3d')
+	try:
+		import importlib as _il
+		qfluid = _il.import_module('fluid3d_pyvista')
+		return qfluid
+	except Exception:
+		return None
+
+server = get_server(name="trame3d")
 state, ctrl = server.state, server.controller
 
-# --- App State Defaults ---
+# Register static assets (PNG previews)
+_assets_dir = os.path.join(os.path.dirname(__file__), "Placeholder_Images")
+if os.path.isdir(_assets_dir):
+	try:
+		server.assets.add(path=_assets_dir, prefix="assets")
+	except Exception:
+		pass
+
+# Throttle settings for live plot updates
+_last_qubit_update = 0.0
+_qubit_update_min_interval = 0.05  # seconds
+
+# --------------------------------------------------------------------------------------
+# State Defaults
+# --------------------------------------------------------------------------------------
 state.update({
-    # App/page
-    "logo_src": None,
-    "is_running": False,
-    "simulation_has_run": False,
-    "error_message": "",
-    # Overview selection
-    "problems_selection": None,  # Dropdown in Overview (dummy)
-    # Geometry
-    "geometry_selection": None,  # Free space | Rectangular domain with a heated box (3D)
-    "domain_L": 1.0,
-    "domain_W": 1.0,
-    "domain_H": 1.0,            # 3D
-    # Initial & BC (Rectangular domain)
-    "dist_type": None,          # None | Delta | Gaussian
-    # Delta/Gaussian positions (copied style from EM)
-    "impulse_x": 0.5, "impulse_y": 0.5,
-    "peak_pair": "(0.5, 0.5)",
-    "mu_x": 0.5, "mu_y": 0.5, "sigma_x": 0.25, "sigma_y": 0.15,
-    "mu_pair": "(0.5, 0.5)",
-    "excitation_error_message": "",
-    # Advection / inlet
-    "advecting_field": None,    # Uniform | Swirl | Shear | TGV
-    "inlet_velocity": 1.0,
-    "inlet_temperature": 300.0,
-    # Meshing
-    "nx_slider_index": None,    # index into grid sizes
-    "nx": None,                 # resolved grid points per direction
-    # Backends (dummy like EM)
-    "backend_type": "Simulator",
-    "selected_simulator": "IBM Qiskit simulator",
-    "selected_qpu": "IBM QPU",
-    # Outputs
-    "output_type": "Surface Plot",  # Surface Plot | Line Sampling
-    "qubit_grid_info": "",
-    "qubit_warning": "",
+	# Core inputs
+	"grid_size": 32,
+	"grid_index": 2,  # 0..5 -> [8,16,32,64,128,256]
+	"time_steps": 100,
+	"distribution_type": "Sinusoidal",  # Sinusoidal | Gaussian
+	"vx_expr": "0.2",
+	"vy_expr": "-0.15",
+	"vz_expr": "0.3",
+	"boundary_condition": "Periodic",   # Periodic | Dirichlet | Neumann
+	# Velocity preset selection
+	"advecting_field": "Uniform",       # Uniform | Swirl | Shear | TGV
+	# Simulation / outputs
+	"is_running": False,
+	"run_error": "",
+	"has_frames": False,
+	"download_ready": False,
+	"download_path": None,
+	# Qubit plot info
+	"qubit_grid_info": "Grid Size: 32 × 32 × 32",
+	"qubit_warning": "",
+	# Overview / Backends (ported from qlbm)
+	"problems_selection": None,
+	"backend_type": "Simulator",
+	"selected_simulator": "IBM Qiskit simulator",
+	"selected_qpu": "IBM QPU",
+	# Geometry (for left-side Geometry cell)
+	"geometry_selection": None,
+	"domain_L": 1.0,
+	"domain_W": 1.0,
+	"domain_H": 1.0,
 })
 
-GRID_SIZES = [16, 32, 64, 128, 256, 512, 1024, 2048]
-
-# --- Helpers ---
-def load_logo_data_uri():
-    try:
-        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:
-                    import base64
-                    b64 = base64.b64encode(f.read()).decode("ascii")
-                return f"data:{mime};base64,{b64}"
-    except Exception:
-        pass
-    return None
-
-state.logo_src = load_logo_data_uri()
-
-# --- 3D Qubit Info Function ---
+# --------------------------------------------------------------------------------------
+# Helpers
+# --------------------------------------------------------------------------------------
 def update_qubit_3D_info(grid_size: int):
-    """Generate 3D qubit requirement plot and info message."""
-    try:
-        num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
-        total_qubits = 3 * num_reg_qubits + 3
-        grid_display = f"Grid Size: {grid_size} × {grid_size} × {grid_size}"
-
-        x = np.array([16, 32, 64, 128, 256])
-        y = np.log2(x).astype(int)
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Qubits/Direction', line=dict(color='#7A3DB5', width=3)))
-        fig.add_trace(go.Scatter(x=[grid_size], y=[num_reg_qubits], mode='markers',
-                                 marker=dict(size=12, color='red'), name='Current Selection'))
-        fig.update_layout(
-            xaxis_title="Grid Size (Points/Direction)",
-            yaxis_title="Qubits/Direction",
-            width=616,
-            height=320,
-            margin=dict(l=40, r=20, t=20, b=40)
-        )
-        warning = "⚠️ Warning: Grid sizes > 64 may exceed simulator/memory limits!" if grid_size > 64 else ""
-        return fig, grid_display, total_qubits, warning
-    except Exception:
-        return go.Figure(), "Grid Size: N/A", 0, ""
-
-# --- Controllers ---
+	"""Generate qubit requirement plot and info strings.
+	For a cubic grid: qubits/direction = log2(grid_size).
+	"""
+	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 _mock_simulation(num_reg_qubits, time_steps, distribution_type, vx, vy, vz, boundary_condition):
+	"""Produce a mock 3D scatter figure and JSON frames (placeholder)."""
+	# Random 3D scatter sized by 50 points.
+	x, y, z = np.random.rand(3, 50)
+	fig = go.Figure(data=[go.Scatter3d(
+		x=x, y=y, z=z,
+		mode='markers',
+		marker=dict(size=5, color=z, colorscale='Viridis', opacity=0.85),
+		text=[f"({xi:.2f},{yi:.2f},{zi:.2f})" for xi, yi, zi in zip(x, y, z)],
+		hovertemplate="<b>Point</b><br>X=%{x:.2f}<br>Y=%{y:.2f}<br>Z=%{z:.2f}<extra></extra>",
+	)])
+	fig.update_layout(
+		title=f"Mock 3D Simulation Result ({distribution_type})",
+		scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
+		margin=dict(l=0, r=0, t=40, b=0),
+		showlegend=False,
+	)
+	return fig, [fig.to_json()]
+
+
+def create_zip_from_frames(frames_json_list):
+	"""Create a temporary zip archive containing frame JSON strings."""
+	if not frames_json_list:
+		return None
+	tmp = tempfile.NamedTemporaryFile(suffix="_frames.zip", delete=False)
+	tmp.close()
+	with zipfile.ZipFile(tmp.name, 'w', zipfile.ZIP_DEFLATED) as zf:
+		for i, frame_json in enumerate(frames_json_list):
+			zf.writestr(f"frame_{i}.json", frame_json)
+	return tmp.name
+
+
+def _ensure_sympy_import():
+	global symbols, sympify, lambdify
+	if symbols is None or sympify is None or lambdify is None:
+		try:
+			sym = importlib.import_module("sympy")
+			symbols = sym.symbols
+			sympify = sym.sympify
+			lambdify = sym.lambdify
+		except Exception:
+			symbols = sympify = lambdify = None
+
+
+def _build_velocity_functions(vx_expr: str, vy_expr: str, vz_expr: str):
+	"""Return callables vx(x,y,z), vy(x,y,z), vz(x,y,z) from user expressions.
+	Fallback to constants if SymPy is unavailable or parsing fails."""
+	_ensure_sympy_import()
+	if symbols and sympify and lambdify:
+		x_sym, y_sym, z_sym = symbols('x y z')
+		try:
+			vx_sym = sympify(vx_expr)
+			vy_sym = sympify(vy_expr)
+			vz_sym = sympify(vz_expr)
+			vx_fn = lambdify((x_sym, y_sym, z_sym), vx_sym, modules="numpy")
+			vy_fn = lambdify((x_sym, y_sym, z_sym), vy_sym, modules="numpy")
+			vz_fn = lambdify((x_sym, y_sym, z_sym), vz_sym, modules="numpy")
+			return vx_fn, vy_fn, vz_fn
+		except Exception:
+			pass
+	# Fallback to constant-valued functions
+	try:
+		cx = float(vx_expr)
+	except Exception:
+		cx = 0.0
+	try:
+		cy = float(vy_expr)
+	except Exception:
+		cy = 0.0
+	try:
+		cz = float(vz_expr)
+	except Exception:
+		cz = 0.0
+	return (
+		lambda x, y, z, _cx=cx: _cx,
+		lambda x, y, z, _cy=cy: _cy,
+		lambda x, y, z, _cz=cz: _cz,
+	)
+
+
+ 
+
+
+# --------------------------------------------------------------------------------------
+# Simulation Controller
+# --------------------------------------------------------------------------------------
 def run_simulation():
-    state.is_running = True
-    state.error_message = ""
-    try:
-        # Placeholder for compute
-        state.simulation_has_run = True
-    except Exception as e:
-        state.error_message = f"Run failed: {e}"
-    finally:
-        state.is_running = False
-
-
-def reset_all():
-    state.update({
-        "problems_selection": None,
-        "geometry_selection": None,
-        "domain_L": 1.0,
-        "domain_W": 1.0,
-        "domain_H": 1.0,
-        "dist_type": None,
-        "impulse_x": 0.5,
-        "impulse_y": 0.5,
-        "peak_pair": "(0.5, 0.5)",
-        "mu_x": 0.5,
-        "mu_y": 0.5,
-        "sigma_x": 0.25,
-        "sigma_y": 0.15,
-        "mu_pair": "(0.5, 0.5)",
-        "excitation_error_message": "",
-        "advecting_field": None,
-        "inlet_velocity": 1.0,
-        "inlet_temperature": 300.0,
-        "nx_slider_index": None,
-        "nx": None,
-        "output_type": "Surface Plot",
-        "is_running": False,
-        "simulation_has_run": False,
-        "error_message": "",
-        "backend_type": "Simulator",
-        "selected_simulator": "IBM Qiskit simulator",
-        "selected_qpu": "IBM QPU",
-        "qubit_grid_info": "",
-        "qubit_warning": "",
-    })
-    # No plotting on reset
-
-
-@state.change("nx_slider_index")
-def on_nx_index_change(nx_slider_index, **_):
-    try:
-        state.nx = GRID_SIZES[int(nx_slider_index)] if nx_slider_index is not None else None
-    except Exception:
-        state.nx = None
-
-# Pair parsing like EM page
-@state.change("peak_pair")
-def sync_peak_pair(peak_pair, **_):
-    import re
-    try:
-        m = re.match(r"\(\s*([0-9]*\.?[0-9]+)\s*,\s*([0-9]*\.?[0-9]+)\s*\)", str(peak_pair))
-        if not m:
-            raise ValueError("Invalid format")
-        x = max(0.0, min(1.0, float(m.group(1))))
-        y = max(0.0, min(1.0, float(m.group(2))))
-        state.impulse_x = x
-        state.impulse_y = y
-        state.excitation_error_message = ""
-    except Exception:
-        state.excitation_error_message = "Invalid Peak. Use (x, y) in [0,1]."
-    # No preview plotting
-
-
-@state.change("mu_pair")
-def sync_mu_pair(mu_pair, **_):
-    import re
-    try:
-        m = re.match(r"\(\s*([-+]?[0-9]*\.?[0-9]+)\s*,\s*([-+]?[0-9]*\.?[0-9]+)\s*\)", str(mu_pair))
-        if not m:
-            raise ValueError("Invalid format")
-        x = max(0.0, min(1.0, float(m.group(1))))
-        y = max(0.0, min(1.0, float(m.group(2))))
-        state.mu_x = x
-        state.mu_y = y
-        state.excitation_error_message = ""
-    except Exception:
-        state.excitation_error_message = "Invalid Mu. Use (x, y) in [0,1]."
-    # No preview plotting
-
-
-@state.change("dist_type", "mu_x", "mu_y", "sigma_x", "sigma_y", "impulse_x", "impulse_y", "nx")
-def on_preview_params_change(**_):
-    # No preview plotting on the right side
-    return
-
-# --- UI ---
+	if state.is_running:
+		return
+	state.is_running = True
+	state.run_error = ""
+	state.download_ready = False
+	state.download_path = None
+	try:
+		# Determine qubits from grid size
+		num_reg_qubits = int(math.log2(state.grid_size)) if state.grid_size and state.grid_size > 0 else 3
+		fig = None
+		frames = []
+		try:
+			# Lazy import like trial.py (single-process behavior)
+			fluid = importlib.import_module('fluid')
+			# Build constant velocity functions to avoid SymPy in critical path
+			def _const(s, d=0.0):
+				try:
+					return float(s)
+				except Exception:
+					return d
+			cx, cy, cz = _const(state.vx_expr), _const(state.vy_expr), _const(state.vz_expr)
+			vx = lambda x, y, z, _cx=cx: _cx
+			vy = lambda x, y, z, _cy=cy: _cy
+			vz = lambda x, y, z, _cz=cz: _cz
+			fig, frames = fluid.simulate_qlbm_3D_and_animate(
+				num_reg_qubits=num_reg_qubits,
+				T=state.time_steps,
+				distribution_type=state.distribution_type,
+				vx_input=vx,
+				vy_input=vy,
+				vz_input=vz,
+				boundary_condition=state.boundary_condition,
+			)
+		except Exception as e:
+			state.run_error = f"Simulation failed: {e}. Falling back to mock visualization."
+		if fig is None:
+			fig, frames = _mock_simulation(
+				num_reg_qubits=num_reg_qubits,
+				time_steps=state.time_steps,
+				distribution_type=state.distribution_type,
+				vx=state.vx_expr,
+				vy=state.vy_expr,
+				vz=state.vz_expr,
+				boundary_condition=state.boundary_condition,
+			)
+		if fig is None:
+			state.run_error = "Simulation returned no figure. Check GPU/driver and parameters."
+			return
+		if hasattr(ctrl, "sim_plot_update"):
+			ctrl.sim_plot_update(fig)
+		# Prepare frames for download (if provided)
+		state.has_frames = bool(frames)
+		state._frames_cache = frames or []  # private cache
+		# Enable download button
+		state.download_ready = bool(frames)
+	except Exception as e:
+		state.run_error = f"Simulation failed: {e}"
+	finally:
+		state.is_running = False
+
+
+def download_frames():
+	if not state.has_frames:
+		return
+	path = create_zip_from_frames(getattr(state, "_frames_cache", []))
+	if path:
+		state.download_path = path
+		# Trigger file download
+		return server.file(path, "plotly_frames.zip")
+
+
+def download_sinusoidal_stl():
+	path = os.path.abspath(os.path.join(os.path.dirname(__file__), "Placeholder_Images", "sinusoidal_surface.stl"))
+	if os.path.exists(path):
+		return server.file(path, filename="sinusoidal_surface.stl")
+
+
+def download_gaussian_stl():
+	path = os.path.abspath(os.path.join(os.path.dirname(__file__), "Placeholder_Images", "gaussian_surface.stl"))
+	if os.path.exists(path):
+		return server.file(path, filename="gaussian_surface.stl")
+
+
+def set_example(dist_type):
+	"""Load an example initial distribution configuration."""
+	state.grid_size = 32
+	state.time_steps = 100
+	state.distribution_type = dist_type
+	state.vx_expr = "0.2"
+	state.vy_expr = "-0.15"
+	state.vz_expr = "0.3"
+	state.boundary_condition = "Periodic"
+
+
+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
+
+@state.change("advecting_field")
+def _on_advect_dropdown_change(advecting_field, **_):
+	if advecting_field:
+		set_velocity_preset(advecting_field)
+
+
+# --------------------------------------------------------------------------------------
+# Reactive updates
+# --------------------------------------------------------------------------------------
+@state.change("grid_size")
+def _on_grid_size_change(grid_size, **_):
+	try:
+		# Restrict to powers of two in [8, 16, 32, 64, 128, 256]
+		allowed = [8, 16, 32, 64, 128, 256]
+		if grid_size not in allowed:
+			# snap to nearest allowed value
+			nearest = min(allowed, key=lambda v: abs(v - (grid_size or 0)))
+			state.grid_size = nearest
+			return
+		# Throttle frequent updates while dragging
+		global _last_qubit_update
+		now = time.time()
+		if (now - _last_qubit_update) < _qubit_update_min_interval:
+			return
+		_last_qubit_update = now
+		fig, info, warn = update_qubit_3D_info(grid_size)
+		state.qubit_grid_info = info
+		state.qubit_warning = warn
+		if hasattr(ctrl, "qubit_plot_update"):
+			ctrl.qubit_plot_update(fig)
+	except Exception:
+		pass
+
+
+@state.change("boundary_condition")
+def _force_periodic(boundary_condition, **_):
+	"""Ensure boundary condition remains 'Periodic' regardless of user selection."""
+	try:
+		if boundary_condition != "Periodic":
+			state.boundary_condition = "Periodic"
+	except Exception:
+		state.boundary_condition = "Periodic"
+
+
+@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) and problems_selection.startswith("1."):
+			# Scalar advection-diffusion in a box
+			state.geometry_selection = "Cube"
+		elif isinstance(problems_selection, str) and problems_selection.startswith("2."):
+			# Laminar flow & heat transfer for a heated body in water.
+			state.geometry_selection = "Rectangular domain with a heated box (3D)"
+		else:
+			state.geometry_selection = None
+	except Exception:
+		state.geometry_selection = None
+
+
+@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]
+			if state.grid_size != val:
+				state.grid_size = val
+	except Exception:
+		pass
+
+
+# --------------------------------------------------------------------------------------
+# UI Construction
+# --------------------------------------------------------------------------------------
 with SinglePageLayout(server) as layout:
-    layout.title.set_text("QLBM: Lattice Boltzmann")
-    layout.title.style = "color: #5f259f; font-weight: 600;"
-    layout.toolbar.classes = "pl-2 pr-1 py-1 elevation-0"
-    layout.toolbar.style = "background-color: #ffffff; border-bottom: 3px solid #5f259f;"
-
-    # Theme tweaks to match EM page
-    trame_html.Style(
-        """
-        :root{
-          --v-theme-primary: 95, 37, 159;       /* #5F259F */
-          --v-theme-secondary: 122, 61, 181;    /* #7A3DB5 */
-          --v-theme-accent: 174, 139, 216;      /* #AE8BD8 */
-          --v-theme-surface: 255, 255, 255;     /* #FFFFFF */
-          --v-theme-background: 255, 255, 255;  /* #FFFFFF */
-          --v-theme-on-primary: 255, 255, 255;  /* #FFFFFF */
-          --v-theme-on-surface: 26, 26, 26;     /* #1A1A1A */
-        }
-        .syn-title{ color:#5f259f !important; }
-        .syn-border-bottom{ border-bottom:3px solid #5f259f !important; }
-        .syn-bg-white{ background:#ffffff !important; }
-        .v-list .v-list-item:hover { background-color: rgba(95,37,159,.08) !important; }
-        .v-list-item--active { background-color: rgba(95,37,159,.16) !important; color: #5f259f !important; }
-        """
-    )
-
-    with layout.toolbar:
-        vuetify3.VSpacer()
-        vuetify3.VImg(v_if="logo_src", src=("logo_src", None), style="height: 56px; width: auto; margin-right: 0px;", classes="mr-0")
-
-    with layout.content:
-        with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-            with vuetify3.VRow(no_gutters=True, classes="fill-height"):
-                # Left column
-                with vuetify3.VCol(cols=5, classes="pa-4 d-flex flex-column"):
-                    # Cell 1: Overview
-                    with vuetify3.VCard(classes="mb-4"):
-                        vuetify3.VCardTitle("Overview", classes="text-h5 font-weight-bold text-primary")
-                        with vuetify3.VCardText():
-                            vuetify3.VDivider(classes="my-2")
-                            vuetify3.VCardSubtitle("Problems!", classes="text-subtitle-1 font-weight-bold mt-2")
-                            vuetify3.VSelect(
-                                key="overview_problems",
-                                label="Select a problem",
-                                v_model=("problems_selection", None),
-                                items=(
-                                    "qlbm_problems",
-                                    [
-                                        "1. Scalar advection-diffusion in a box",
-                                        "2. Laminar flow & heat transfer for a heated body in water.",
-                                    ],
-                                ),
-                                placeholder="Select",
-                                density="compact",
-                                color="primary",
-                            )
-                            vuetify3.VCardSubtitle("Governing Equations", classes="text-subtitle-1 font-weight-bold mt-2")
-                            vuetify3.VListItemTitle("Laminar Navier-Stokes including energy", classes="text-body-2")
-                            vuetify3.VCardSubtitle("Inputs", classes="text-subtitle-1 font-weight-bold mt-2")
-                            vuetify3.VListItemTitle("Geometry, Boundary conditions - temperature and flow", classes="text-body-2")
-                            vuetify3.VCardSubtitle("Outputs", classes="text-subtitle-1 font-weight-bold mt-2")
-                            vuetify3.VListItemTitle("Surface plots on sections OR sampling through a line in 3D domain", classes="text-body-2")
-
-                    # Cell 2: Geometry
-                    with vuetify3.VCard(classes="mb-4"):
-                        vuetify3.VCardTitle("Geometry", classes="text-primary")
-                        with vuetify3.VCardText():
-                            vuetify3.VSelect(
-                                key="geom_select",
-                                label="Select",
-                                v_model=("geometry_selection", None),
-                                items=(
-                                    "geometry_options",
-                                    [
-                                        "Free space",
-                                        "Rectangular domain with a heated box (3D)",
-                                    ],
-                                ),
-                                placeholder="Select",
-                                density="compact",
-                                color="primary",
-                            )
-                            # Domain dimensions - NO DUPLICATES
-                            with vuetify3.VContainer(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="pa-0 mt-2"):
-                                with vuetify3.VRow(dense=True):
-                                    vuetify3.VCol(children=[vuetify3.VTextField(key="geom_len", label="Length (L)", v_model=("domain_L", 1.0), type="number", step="0.1", density="compact", color="primary")])
-                                    vuetify3.VCol(children=[vuetify3.VTextField(key="geom_breadth", label="Breadth (B)", v_model=("domain_W", 1.0), type="number", step="0.1", density="compact", color="primary")])
-                                vuetify3.VTextField(key="geom_height", label="Height (H)", v_model=("domain_H", 1.0), type="number", step="0.1", density="compact", color="primary")
-
-                    # Cell 3: Initial & Boundary Conditions (only when Rectangular selected)
-                    with vuetify3.VCard(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="mb-4"):
-                        vuetify3.VCardTitle("Initial & Boundary Conditions", classes="text-primary")
-                        with vuetify3.VCardText():
-                            # Initial distribution (Gaussian only) - NO DUPLICATES
-                            vuetify3.VTextField(key="gauss_mu", v_model=("mu_pair", "(0.5, 0.5)"), label="Gaussian μ (x, y) in [0,1]", density="compact", color="primary")
-                            with vuetify3.VRow(dense=True, classes="mt-1"):
-                                vuetify3.VCol(children=[vuetify3.VTextField(key="sigma_x", label="Sigma X (0–1)", v_model=("sigma_x", 0.25), type="number", step="0.01", density="compact", color="primary")])
-                                vuetify3.VCol(children=[vuetify3.VTextField(key="sigma_y", label="Sigma Y (0–1)", v_model=("sigma_y", 0.15), type="number", step="0.01", density="compact", color="primary")])
-                            vuetify3.VAlert(v_if="excitation_error_message", type="error", variant="tonal", density="compact", children=["{{ excitation_error_message }}"], classes="mt-2")
-
-                            # Advecting field
-                            vuetify3.VSelect(key="adv_field", label="Advecting field", v_model=("advecting_field", None), items=("advect_fields", ["Uniform", "Swirl", "Shear", "TGV"]), density="compact", color="primary", classes="mt-2")
-                            
-                            # Inlet (single set) - NO DUPLICATES
-                            with vuetify3.VRow(dense=True, classes="mt-2"):
-                                vuetify3.VCol(children=[vuetify3.VTextField(key="inlet_vel", label="Inlet flow velocity", v_model=("inlet_velocity", 1.0), type="number", step="0.1", density="compact", color="primary")])
-                                vuetify3.VCol(children=[vuetify3.VTextField(key="inlet_temp", label="Inlet temperature (K)", v_model=("inlet_temperature", 300.0), type="number", step="1", density="compact", color="primary")])
-
-                    # Cell 4: Meshing
-                    with vuetify3.VCard(classes="mb-4"):
-                        vuetify3.VCardTitle("Meshing", classes="text-primary")
-                        with vuetify3.VCardText():
-                            with vuetify3.VMenu(open_on_hover=True, close_on_content_click=False, location="end"):
-                                with vuetify3.Template(v_slot_activator="{ props }"):
-                                    with vuetify3.VSlider(
-                                        key="mesh_slider",
-                                        v_bind="props",
-                                        v_model=("nx_slider_index", None),
-                                        label="No. of points per direction:",
-                                        min=0,
-                                        max=len(GRID_SIZES) - 1,
-                                        step=1,
-                                        show_ticks="always",
-                                        thumb_label="always",
-                                        density="compact",
-                                        color="primary",
-                                    ):
-                                        # Keep labels in sync with GRID_SIZES
-                                        vuetify3.Template(v_slot_thumb_label="{ modelValue }", children=["{{ modelValue === null ? 'Select' : [16, 32, 64, 128, 256, 512, 1024, 2048][modelValue] }}"])
-                                with vuetify3.VSheet(classes="pa-2", elevation=6, rounded=True, style="width: 700px;"):
-                                    with vuetify3.VContainer(fluid=True, classes="pa-0"):
-                                        qubit_fig_widget = plotly_widgets.Figure(
-                                            figure=go.Figure(),
-                                            responsive=True,
-                                            style="width: 616px; height: 320px; min-height: 320px;",
-                                        )
-                                        vuetify3.VCardText(children=["{{ qubit_grid_info }}", "{{ qubit_warning }}"], classes="text-caption mt-2")
-
-                    # Cell 5: Backends (dummy like EM)
-                    with vuetify3.VCard(classes="mb-4"):
-                        vuetify3.VCardTitle("Backends", classes="text-primary")
-                        with vuetify3.VCardText():
-                            with vuetify3.VRow(dense=True, classes="mb-2"):
-                                with vuetify3.VCol():
-                                    vuetify3.VAlert(
-                                        type="info",
-                                        color="primary",
-                                        variant="tonal",
-                                        density="compact",
-                                        children=[
-                                            "Selected: ",
-                                            "{{ backend_type || '—' }}",
-                                            " - ",
-                                            "{{ backend_type === 'Simulator' ? selected_simulator : (backend_type === 'QPU' ? selected_qpu : '—') }}",
-                                        ],
-                                    )
-                            with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end"):
-                                with vuetify3.Template(v_slot_activator="{ props }"):
-                                    vuetify3.VBtn(v_bind="props", text="Choose Backend", color="primary", variant="tonal", block=True)
-                                with vuetify3.VList(density="compact"):
-                                    with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
-                                        with vuetify3.Template(v_slot_activator="{ props }"):
-                                            vuetify3.VListItem(v_bind="props", title="Simulator", prepend_icon="mdi-robot-outline", append_icon="mdi-chevron-right")
-                                        with vuetify3.VList(density="compact"):
-                                            vuetify3.VListItem(title="IBM Qiskit simulator", click="backend_type = 'Simulator'; selected_simulator = 'IBM Qiskit simulator'")
-                                            vuetify3.VListItem(title="IonQ simulator", click="backend_type = 'Simulator'; selected_simulator = 'IonQ simulator'")
-                                    with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
-                                        with vuetify3.Template(v_slot_activator="{ props }"):
-                                            vuetify3.VListItem(v_bind="props", title="QPU", prepend_icon="mdi-chip", append_icon="mdi-chevron-right")
-                                        with vuetify3.VList(density="compact"):
-                                            vuetify3.VListItem(title="IBM QPU", click="backend_type = 'QPU'; selected_qpu = 'IBM QPU'")
-                                            vuetify3.VListItem(title="IonQ QPU", click="backend_type = 'QPU'; selected_qpu = 'IonQ QPU'")
-
-                    # Actions - SINGLE ROW WITH TWO BUTTONS
-                    with vuetify3.VRow(dense=True, classes="gap-2 mt-4"):
-                        with vuetify3.VCol():
-                            vuetify3.VBtn(
-                                text="Run Simulation",
-                                color="primary",
-                                block=True,
-                                disabled=("is_running || !geometry_selection || (geometry_selection === 'Rectangular domain with a heated box (3D)' && nx === null)", False),
-                                click=run_simulation
-                            )
-                        with vuetify3.VCol():
-                            vuetify3.VBtn(
-                                text="Reset",
-                                color="secondary",
-                                variant="tonal",
-                                block=True,
-                                click=reset_all
-                            )
-
-                # Right column: Output area
-                with vuetify3.VCol(cols=7, classes="pa-4 d-flex flex-column"):
-                    with vuetify3.VContainer(fluid=True, classes="fill-height d-flex align-center justify-center"):
-                        vuetify3.VCardText("Select a geometry and configure inputs to display results.", classes="text-center text-medium-emphasis")
-
-# Update qubit hover plot when nx changes
-ctrl.qubit_plot_update = qubit_fig_widget.update
-
-@state.change("nx")
-def _update_qubit_plot(nx, **_):
-    try:
-        fig = None
-        if nx is None:
-            state.qubit_grid_info = ""
-            state.qubit_warning = ""
-        else:
-            fig, grid_info, total_qubits, warning = update_qubit_3D_info(nx)
-            state.qubit_grid_info = grid_info
-            state.qubit_warning = warning
-        if hasattr(ctrl, 'qubit_plot_update') and fig is not None:
-            ctrl.qubit_plot_update(fig)
-    except Exception:
-        pass
-
-# --- Entry point helpers for embedding ---
-_q_lb_started = False
+	# Remove top toolbar/title per request
+	layout.toolbar.style = "display:none"  # Hide toolbar entirely
+
+	trame_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; }
+	""")
+
+	# No toolbar content
+
+	with layout.content:
+		with vuetify3.VContainer(fluid=True, classes="pa-4"):
+			# Row 1: Overview + Geometry + Examples (left) and Visualization (right)
+			with vuetify3.VRow(classes="mb-4"):
+				# Left column (Overview, Geometry, Examples)
+				with vuetify3.VCol(cols=5):
+					# Overview cell (from qlbm)
+					with vuetify3.VCard(classes="mb-4"):
+						vuetify3.VCardTitle("Overview", classes="text-h5 font-weight-bold text-primary")
+						with vuetify3.VCardText():
+							vuetify3.VDivider(classes="my-2")
+							vuetify3.VCardSubtitle("Problems", classes="text-subtitle-1 font-weight-bold mt-2")
+							vuetify3.VSelect(
+								key="overview_problems",
+								label="Select a problem",
+								v_model=("problems_selection", None),
+								items=(
+									"qlbm_problems",
+									[
+										"1. Scalar advection-diffusion in a box",
+										"2. Laminar flow & heat transfer for a heated body in water.",
+									],
+								),
+								placeholder="Select",
+								density="compact",
+								color="primary",
+							)
+							vuetify3.VCardSubtitle("Governing Equations", classes="text-subtitle-1 font-weight-bold mt-2")
+							vuetify3.VListItemTitle("Laminar Navier-Stokes including energy", classes="text-body-2")
+							vuetify3.VCardSubtitle("Inputs", classes="text-subtitle-1 font-weight-bold mt-2")
+							vuetify3.VListItemTitle("Geometry, Boundary conditions - temperature and flow", classes="text-body-2")
+							vuetify3.VCardSubtitle("Outputs", classes="text-subtitle-1 font-weight-bold mt-2")
+							vuetify3.VListItemTitle("Surface plots on sections OR sampling through a line in 3D domain", classes="text-body-2")
+
+						# Geometry cell
+						with vuetify3.VCard(classes="mb-4"):
+							vuetify3.VCardTitle("Geometry", classes="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 }}"],
+								)
+								vuetify3.VAlert(
+									v_if="!geometry_selection",
+									type="info",
+									variant="tonal",
+									density="compact",
+									color="primary",
+									children=["No geometry selected. Choose a problem to auto-set."],
+								)
+								with vuetify3.VContainer(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="pa-0 mt-4"):
+									vuetify3.VCardSubtitle("Domain dimensions", classes="text-subtitle-1 font-weight-bold mb-2")
+									with vuetify3.VRow(dense=True):
+										vuetify3.VCol(children=[vuetify3.VTextField(label="Length (L)", v_model=("domain_L", 1.0), type="number", step="0.1", density="compact", color="primary")])
+										vuetify3.VCol(children=[vuetify3.VTextField(label="Width (W)", v_model=("domain_W", 1.0), type="number", step="0.1", density="compact", color="primary")])
+										vuetify3.VCol(children=[vuetify3.VTextField(label="Height (H)", v_model=("domain_H", 1.0), type="number", step="0.1", density="compact", color="primary")])
+
+					# Initial Distribution Examples card removed per latest UI request
+
+					# (Simulation Parameters: moved here to avoid vertical gap)
+
+					# Combined Initial & Boundary Conditions
+					with vuetify3.VCard(classes="mb-4"):
+						vuetify3.VCardTitle("Initial & Boundary Conditions", classes="text-primary")
+						with vuetify3.VCardText():
+							vuetify3.VSelect(label="Initial Distribution Type", v_model=("distribution_type", "Sinusoidal"), items=("dist_types", ["Gaussian", "Sinusoidal"]), density="compact", color="primary")
+							# Boundary condition restricted to Periodic only
+							vuetify3.VSelect(label="Boundary Condition", v_model=("boundary_condition", "Periodic"), items=("bc_types", ["Periodic"]), density="compact", color="primary", classes="mt-2")
+
+					# Advecting Fields card
+					with vuetify3.VCard(classes="mb-4"):
+						vuetify3.VCardTitle("Advecting Fields", classes="text-primary")
+						with vuetify3.VCardText():
+							vuetify3.VSelect(
+								label="Select Advecting field",
+								v_model=("advecting_field", "Uniform"),
+								items=("adv_presets", ["Uniform", "Swirl", "Shear", "TGV"]),
+								density="compact",
+								color="primary"
+							)
+							trame_html.Div("Velocity Components", classes="text-body-2 mt-4")
+							vuetify3.VTextField(label="Velocity vx", v_model=("vx_expr", "0.2"), density="compact", color="primary")
+							vuetify3.VTextField(label="Velocity vy", v_model=("vy_expr", "-0.15"), density="compact", color="primary")
+							vuetify3.VTextField(label="Velocity vz", v_model=("vz_expr", "0.3"), density="compact", color="primary")
+
+					# Meshing
+					with vuetify3.VCard(classes="mb-4"):
+						vuetify3.VCardTitle("Meshing", classes="text-primary")
+						with vuetify3.VCardText():
+							with vuetify3.VMenu(open_on_hover=True, close_on_content_click=False, location="end"):
+								with vuetify3.Template(v_slot_activator="{ props }"):
+									with vuetify3.VSlider(
+										v_bind="props",
+										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"
+									):
+										# Map index -> power-of-two label
+										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)
+										trame_html.Div("{{ qubit_grid_info }}", classes="mt-2 text-caption")
+										trame_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-4"):
+						vuetify3.VCardTitle("Time", classes="text-primary")
+						with vuetify3.VCardText():
+							vuetify3.VSlider(label="Time Steps", v_model=("time_steps", 100), min=0, max=2000, step=10, thumb_label="always", show_ticks="always", color="primary", density="compact")
+							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 cell (from qlbm) with Run button beneath
+					with vuetify3.VCard(classes="mb-4"):
+						vuetify3.VCardTitle("Backends", classes="text-primary")
+						with vuetify3.VCardText():
+							with vuetify3.VRow(dense=True, classes="mb-2"):
+								with vuetify3.VCol():
+									vuetify3.VAlert(
+										type="info",
+										color="primary",
+										variant="tonal",
+										density="compact",
+										children=[
+											"Selected: ",
+											"{{ backend_type || '—' }}",
+											" - ",
+											"{{ backend_type === 'Simulator' ? selected_simulator : (backend_type === 'QPU' ? selected_qpu : '—') }}",
+										],
+									)
+							with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end"):
+								with vuetify3.Template(v_slot_activator="{ props }"):
+									vuetify3.VBtn(v_bind="props", text="Choose Backend", color="primary", variant="tonal", block=True)
+								with vuetify3.VList(density="compact"):
+									with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
+										with vuetify3.Template(v_slot_activator="{ props }"):
+											vuetify3.VListItem(v_bind="props", title="Simulator", prepend_icon="mdi-robot-outline", append_icon="mdi-chevron-right")
+										with vuetify3.VList(density="compact"):
+											vuetify3.VListItem(title="IBM Qiskit simulator", click="backend_type = 'Simulator'; selected_simulator = 'IBM Qiskit simulator'")
+											vuetify3.VListItem(title="IonQ simulator", click="backend_type = 'Simulator'; selected_simulator = 'IonQ simulator'")
+									with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
+										with vuetify3.Template(v_slot_activator="{ props }"):
+											vuetify3.VListItem(v_bind="props", title="QPU", prepend_icon="mdi-chip", append_icon="mdi-chevron-right")
+										with vuetify3.VList(density="compact"):
+											vuetify3.VListItem(title="IBM QPU", click="backend_type = 'QPU'; selected_qpu = 'IBM QPU'")
+											vuetify3.VListItem(title="IonQ QPU", click="backend_type = 'QPU'; selected_qpu = 'IonQ QPU'")
+							vuetify3.VDivider(classes="my-3")
+							vuetify3.VBtn(text="Run Simulation", color="primary", block=True, disabled=("is_running", False), click=run_simulation)
+
+				# Right column (Visualization)
+				with vuetify3.VCol(cols=7):
+					with vuetify3.VCard(classes="fill-height"):
+						vuetify3.VCardTitle("QLBM 3D Visualization", classes="text-primary")
+						with vuetify3.VCardText(classes="pb-2", style="min-height:760px;display:flex;flex-direction:column;"):
+							vuetify3.VProgressCircular(v_if="is_running", indeterminate=True, color="primary", size=64, classes="my-4 mx-auto d-flex")
+							sim_fig = plotly_widgets.Figure(figure=go.Figure(), style="width:100%;height:700px;", responsive=True)
+							vuetify3.VAlert(v_if="run_error", type="error", variant="tonal", density="compact", children=["{{ run_error }}"], classes="mt-2")
+						# Removed Download Plot Data button per request
+
+			# Row 2 removed to keep left panel contiguous with Geometry (no vertical gap)
+
+# Controller hooks for plot updates
+ctrl.qubit_plot_update = qubit_fig.update
+ctrl.sim_plot_update = sim_fig.update
+
+# --------------------------------------------------------------------------------------
+# Embedding helper
+# --------------------------------------------------------------------------------------
+_started = False
+
+def build(host_server):
+	"""Embed this app into another Trame server via an iframe, auto-starting its own server."""
+	global _started
+	if not _started:
+		import threading
+		def _run():
+			try:
+				port = int(os.environ.get("TRAME3D_PORT", "8811"))
+				server.start(host="0.0.0.0", port=port, open_browser=False)
+			except Exception as e:
+				print(f"trame3d server failed to start: {e}")
+		threading.Thread(target=_run, daemon=True).start()
+		_started = True
+	h_state = host_server.state
+	default_port = os.environ.get("TRAME3D_PORT", "8811")
+	if not getattr(h_state, "trame3d_iframe_src", None):
+		h_state.trame3d_iframe_src = f"http://localhost:{default_port}/"
+	with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+		trame_html.Iframe(src=("trame3d_iframe_src", f"http://localhost:{default_port}/"), style="border:0; width:100%; height: calc(100vh - 64px);")
+		trame_html.Div("If the 3D QLBM view is blank, wait a few seconds or verify TRAME3D_PORT.", style="color: rgba(0,0,0,.6); padding: 6px;")
+
+# Controller hooks for plot updates
+ctrl.qubit_plot_update = qubit_fig.update
+ctrl.sim_plot_update = sim_fig.update
+
+# --------------------------------------------------------------------------------------
+# Embedding helper
+# --------------------------------------------------------------------------------------
+_started = False
 
 def build(host_server):
-    """Embed QLBM UI directly (no iframe, no separate server)."""
-    global state, ctrl, _q_lb_started, qubit_fig_widget
-    state, ctrl = host_server.state, host_server.controller
-
-    # Initialize defaults only if missing (avoid overwriting existing host state)
-    required_keys = ["is_running","simulation_has_run","qubit_grid_info","qubit_warning"]
-    if any(not hasattr(state, k) for k in required_keys):
-        state.update({
-            "logo_src": getattr(state, "logo_src", None),
-            "is_running": False,
-            "simulation_has_run": False,
-            "error_message": "",
-            "problems_selection": None,
-            "geometry_selection": None,
-            "domain_L": 1.0,
-            "domain_W": 1.0,
-            "domain_H": 1.0,
-            "dist_type": None,
-            "impulse_x": 0.5, "impulse_y": 0.5, "peak_pair": "(0.5, 0.5)",
-            "mu_x": 0.5, "mu_y": 0.5, "sigma_x": 0.25, "sigma_y": 0.15, "mu_pair": "(0.5, 0.5)",
-            "excitation_error_message": "",
-            "advecting_field": None,
-            "inlet_velocity": 1.0,
-            "inlet_temperature": 300.0,
-            "nx_slider_index": None,
-            "nx": None,
-            "backend_type": "Simulator",
-            "selected_simulator": "IBM Qiskit simulator",
-            "selected_qpu": "IBM QPU",
-            "output_type": "Surface Plot",
-            "qubit_grid_info": "",
-            "qubit_warning": "",
-        })
-
-    # UI (previously inside SinglePageLayout.content)
-    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-        with vuetify3.VRow(no_gutters=True, classes="fill-height"):
-            # Left column
-            with vuetify3.VCol(cols=5, classes="pa-4 d-flex flex-column"):
-                # Overview
-                with vuetify3.VCard(classes="mb-4"):
-                    vuetify3.VCardTitle("Overview", classes="text-h5 font-weight-bold text-primary")
-                    with vuetify3.VCardText():
-                        vuetify3.VDivider(classes="my-2")
-                        vuetify3.VCardSubtitle("Problems!", classes="text-subtitle-1 font-weight-bold mt-2")
-                        vuetify3.VSelect(
-                            key="overview_problems",
-                            label="Select a problem",
-                            v_model=("problems_selection", None),
-                            items=("qlbm_problems", [
-                                "1. Scalar advection-diffusion in a box",
-                                "2. Laminar flow & heat transfer for a heated body in water.",
-                            ]),
-                            placeholder="Select",
-                            density="compact",
-                            color="primary",
-                        )
-                        vuetify3.VCardSubtitle("Governing Equations", classes="text-subtitle-1 font-weight-bold mt-2")
-                        vuetify3.VListItemTitle("Laminar Navier-Stokes including energy", classes="text-body-2")
-                        vuetify3.VCardSubtitle("Inputs", classes="text-subtitle-1 font-weight-bold mt-2")
-                        vuetify3.VListItemTitle("Geometry, Boundary conditions - temperature and flow", classes="text-body-2")
-                        vuetify3.VCardSubtitle("Outputs", classes="text-subtitle-1 font-weight-bold mt-2")
-                        vuetify3.VListItemTitle("Surface plots on sections OR sampling through a line in 3D domain", classes="text-body-2")
-                # Geometry
-                with vuetify3.VCard(classes="mb-4"):
-                    vuetify3.VCardTitle("Geometry", classes="text-primary")
-                    with vuetify3.VCardText():
-                        vuetify3.VSelect(
-                            key="geom_select",
-                            label="Select",
-                            v_model=("geometry_selection", None),
-                            items=("geometry_options", [
-                                "Free space",
-                                "Rectangular domain with a heated box (3D)",
-                            ]),
-                            placeholder="Select",
-                            density="compact",
-                            color="primary",
-                        )
-                        with vuetify3.VContainer(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="pa-0 mt-2"):
-                            with vuetify3.VRow(dense=True):
-                                vuetify3.VCol(children=[vuetify3.VTextField(key="geom_len", label="Length (L)", v_model=("domain_L", 1.0), type="number", step="0.1", density="compact", color="primary")])
-                                vuetify3.VCol(children=[vuetify3.VTextField(key="geom_breadth", label="Breadth (B)", v_model=("domain_W", 1.0), type="number", step="0.1", density="compact", color="primary")])
-                            vuetify3.VTextField(key="geom_height", label="Height (H)", v_model=("domain_H", 1.0), type="number", step="0.1", density="compact", color="primary")
-                # Initial & BC
-                with vuetify3.VCard(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="mb-4"):
-                    vuetify3.VCardTitle("Initial & Boundary Conditions", classes="text-primary")
-                    with vuetify3.VCardText():
-                        vuetify3.VTextField(key="gauss_mu", v_model=("mu_pair", "(0.5, 0.5)"), label="Gaussian μ (x, y) in [0,1]", density="compact", color="primary")
-                        with vuetify3.VRow(dense=True, classes="mt-1"):
-                            vuetify3.VCol(children=[vuetify3.VTextField(key="sigma_x", label="Sigma X (0–1)", v_model=("sigma_x", 0.25), type="number", step="0.01", density="compact", color="primary")])
-                            vuetify3.VCol(children=[vuetify3.VTextField(key="sigma_y", label="Sigma Y (0–1)", v_model=("sigma_y", 0.15), type="number", step="0.01", density="compact", color="primary")])
-                        vuetify3.VAlert(v_if="excitation_error_message", type="error", variant="tonal", density="compact", children=["{{ excitation_error_message }}"], classes="mt-2")
-                        vuetify3.VSelect(key="adv_field", label="Advecting field", v_model=("advecting_field", None), items=("advect_fields", ["Uniform", "Swirl", "Shear", "TGV"]), density="compact", color="primary", classes="mt-2")
-                        with vuetify3.VRow(dense=True, classes="mt-2"):
-                            vuetify3.VCol(children=[vuetify3.VTextField(key="inlet_vel", label="Inlet flow velocity", v_model=("inlet_velocity", 1.0), type="number", step="0.1", density="compact", color="primary")])
-                            vuetify3.VCol(children=[vuetify3.VTextField(key="inlet_temp", label="Inlet temperature (K)", v_model=("inlet_temperature", 300.0), type="number", step="1", density="compact", color="primary")])
-                # Meshing
-                with vuetify3.VCard(classes="mb-4"):
-                    vuetify3.VCardTitle("Meshing", classes="text-primary")
-                    with vuetify3.VCardText():
-                        with vuetify3.VMenu(open_on_hover=True, close_on_content_click=False, location="end"):
-                            with vuetify3.Template(v_slot_activator="{ props }"):
-                                with vuetify3.VSlider(
-                                    key="mesh_slider",
-                                    v_bind="props",
-                                    v_model=("nx_slider_index", None),
-                                    label="No. of points per direction:",
-                                    min=0,
-                                    max=len(GRID_SIZES) - 1,
-                                    step=1,
-                                    show_ticks="always",
-                                    thumb_label="always",
-                                    density="compact",
-                                    color="primary",
-                                ):
-                                    vuetify3.Template(v_slot_thumb_label="{ modelValue }", children=["{{ modelValue === null ? 'Select' : [16, 32, 64, 128, 256, 512, 1024, 2048][modelValue] }}"])
-                            with vuetify3.VSheet(classes="pa-2", elevation=6, rounded=True, style="width: 700px;"):
-                                with vuetify3.VContainer(fluid=True, classes="pa-0"):
-                                    qubit_fig_widget = plotly_widgets.Figure(
-                                        figure=go.Figure(),
-                                        responsive=True,
-                                        style="width: 616px; height: 320px; min-height: 320px;",
-                                    )
-                                    vuetify3.VCardText(children=["{{ qubit_grid_info }}", "{{ qubit_warning }}"], classes="text-caption mt-2")
-                # Backends
-                with vuetify3.VCard(classes="mb-4"):
-                    vuetify3.VCardTitle("Backends", classes="text-primary")
-                    with vuetify3.VCardText():
-                        with vuetify3.VRow(dense=True, classes="mb-2"):
-                            with vuetify3.VCol():
-                                vuetify3.VAlert(
-                                    type="info",
-                                    color="primary",
-                                    variant="tonal",
-                                    density="compact",
-                                    children=[
-                                        "Selected: ",
-                                        "{{ backend_type || '—' }}",
-                                        " - ",
-                                        "{{ backend_type === 'Simulator' ? selected_simulator : (backend_type === 'QPU' ? selected_qpu : '—') }}",
-                                    ],
-                                )
-                        with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end"):
-                            with vuetify3.Template(v_slot_activator="{ props }"):
-                                vuetify3.VBtn(v_bind="props", text="Choose Backend", color="primary", variant="tonal", block=True)
-                            with vuetify3.VList(density="compact"):
-                                with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
-                                    with vuetify3.Template(v_slot_activator="{ props }"):
-                                        vuetify3.VListItem(v_bind="props", title="Simulator", prepend_icon="mdi-robot-outline", append_icon="mdi-chevron-right")
-                                    with vuetify3.VList(density="compact"):
-                                        vuetify3.VListItem(title="IBM Qiskit simulator", click="backend_type = 'Simulator'; selected_simulator = 'IBM Qiskit simulator'")
-                                        vuetify3.VListItem(title="IonQ simulator", click="backend_type = 'Simulator'; selected_simulator = 'IonQ simulator'")
-                                with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
-                                    with vuetify3.Template(v_slot_activator="{ props }"):
-                                        vuetify3.VListItem(v_bind="props", title="QPU", prepend_icon="mdi-chip", append_icon="mdi-chevron-right")
-                                    with vuetify3.VList(density="compact"):
-                                        vuetify3.VListItem(title="IBM QPU", click="backend_type = 'QPU'; selected_qpu = 'IBM QPU'")
-                                        vuetify3.VListItem(title="IonQ QPU", click="backend_type = 'QPU'; selected_qpu = 'IonQ QPU'")
-                with vuetify3.VRow(dense=True, classes="gap-2 mt-4"):
-                    with vuetify3.VCol():
-                        vuetify3.VBtn(
-                            text="Run Simulation",
-                            color="primary",
-                            block=True,
-                            disabled=("is_running || !geometry_selection || (geometry_selection === 'Rectangular domain with a heated box (3D)' && nx === null)", False),
-                            click=run_simulation
-                        )
-                    with vuetify3.VCol():
-                        vuetify3.VBtn(
-                            text="Reset",
-                            color="secondary",
-                            variant="tonal",
-                            block=True,
-                            click=reset_all
-                        )
-            # Right column
-            with vuetify3.VCol(cols=7, classes="pa-4 d-flex flex-column"):
-                with vuetify3.VContainer(fluid=True, classes="fill-height d-flex align-center justify-center"):
-                    vuetify3.VCardText("Select a geometry and configure inputs to display results.", classes="text-center text-medium-emphasis")
-
-    # Register qubit figure update hook
-    ctrl.qubit_plot_update = qubit_fig_widget.update
-
-    # Re-register state change callbacks on host server
-    host_server.state.change("nx")(_update_qubit_plot)
-    host_server.state.change("peak_pair")(sync_peak_pair)
-    host_server.state.change("mu_pair")(sync_mu_pair)
-    host_server.state.change("dist_type", "mu_x", "mu_y", "sigma_x", "sigma_y", "impulse_x", "impulse_y", "nx")(on_preview_params_change)
+	"""Embed this app into another Trame server via an iframe, auto-starting its own server."""
+	global _started
+	if not _started:
+		import threading
+		def _run():
+			try:
+				port = int(os.environ.get("TRAME3D_PORT", "8811"))
+				server.start(host="0.0.0.0", port=port, open_browser=False)
+			except Exception as e:
+				print(f"trame3d server failed to start: {e}")
+		threading.Thread(target=_run, daemon=True).start()
+		_started = True
+	h_state = host_server.state
+	default_port = os.environ.get("TRAME3D_PORT", "8811")
+	if not getattr(h_state, "trame3d_iframe_src", None):
+		h_state.trame3d_iframe_src = f"http://localhost:{default_port}/"
+	with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+		trame_html.Iframe(src=("trame3d_iframe_src", f"http://localhost:{default_port}/"), style="border:0; width:100%; height: calc(100vh - 64px);")
+		trame_html.Div("If the 3D QLBM view is blank, wait a few seconds or verify TRAME3D_PORT.", style="color: rgba(0,0,0,.6); padding: 6px;")
 
 # --- Entry point ---
 if __name__ == "__main__":

utils/base_ionq.py

@@ -0,0 +1,458 @@
+import numpy as np
+import scipy.sparse as sp
+import math
+import random
+import matplotlib.pyplot as plt
+from scipy.special import jn
+from scipy.sparse import identity, csr_matrix, kron, diags, eye
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.circuit.library import MCXGate, MCPhaseGate, RXGate, CRXGate, QFTGate, StatePreparation, PauliEvolutionGate, RZGate
+from qiskit.quantum_info import SparsePauliOp, Statevector, Operator, Pauli
+from scipy.linalg import expm
+# from tools import *
+from qiskit.qasm3 import dumps  # QASM 3 exporter
+from qiskit.qasm3 import loads
+from qiskit.circuit.library import QFT
+from qiskit.primitives import StatevectorEstimator
+from qiskit import transpile
+from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit, apply_circuit_to_state, compute_overlap
+from qiskit_aer import AerSimulator
+from qiskit_ionq import IonQProvider
+import os
+my_api_key = os.getenv("IONQ_API_KEY")
+from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator
+
+
+
+
+# provider = IonQProvider()
+
+api_token = "SgUkiDq1r2bVEadyiUfvtuxQ03Qci6UW"
+provider = IonQProvider(api_token)
+ionq_backend = provider.get_backend("simulator")
+
+
+
+
+simulator_settings = AerSimulator(
+    method="matrix_product_state",
+    matrix_product_state_max_bond_dimension=100,
+)
+
+def Wj(j, theta, lam, name='Wj', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}$ '
+    qc=QuantumCircuit(j, name=name)
+
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+    if lam != 0:
+        qc.p(lam, j-1)
+    qc.h(j-1)
+    if xgate:
+        qc.x(range(j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        qc.mcrz(theta, range(j-1), j-1)
+    else:
+        qc.rz(theta, j-1)
+    
+    if xgate:
+        qc.x(range(j-1))
+    qc.h(j-1)
+    if lam != 0:
+        qc.p(-lam, j-1)
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+
+    return qc
+
+def Wj_block(j, n, ctrl_state, theta, lam, name='Wj_block', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}_block$ '
+    qc=QuantumCircuit(n + j, name=name)
+
+    if j > 1:
+        qc.cx(n + j-1, range(n, n+j-1))
+    if lam != 0:
+        qc.p(lam, n + j -1)
+    qc.h(n + j -1)
+    
+    if xgate and j>1:
+        if isinstance(xgate, (list, tuple)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        mcrz = RZGate(theta).control(len(ctrl_state) + j-1, ctrl_state = "1"*(j-1)+ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    else:
+        mcrz = RZGate(theta).control(len(ctrl_state), ctrl_state = ctrl_state)
+        qc.append(mcrz, range(0, n+j))
+    
+    if xgate and j>1:
+        if isinstance(xgate, (list, tuple)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+            
+    qc.h(n+ j-1)
+    if lam != 0:
+        qc.p(-lam, n + j-1)
+    if j > 1:
+        qc.cx(n + j-1, range(n, n +j-1))
+
+    return qc.to_gate(label=name)
+
+def V1(nx, dt, name = "V1"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, n, "0"*n, -dt , 0, xgate=True)
+    qc.append(W1, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W2 = Wj_block(3, n-1, "1"*(n-1), dt , 0, xgate=[0,1])
+    qc.append(W2, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(1, n+1, "0"*(n+1), dt , 0, xgate=False)
+    qc.append(W3, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "0"+"1"*(n-1), -dt , 0, xgate=False)
+    qc.append(W4, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    return qc
+
+def V2(nx, dt, name = "V2"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, 0, "", -2*dt , -np.pi/2, xgate=True)
+    qc.append(W1, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W2 = Wj_block(2+j, 0, "", 2*dt , -np.pi/2, xgate=[1]*(j-1)+[0,1])
+        qc.append(W2, list(derivatives[0:j])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(2, n, "0"*n, -dt , -np.pi/2, xgate=True)
+    qc.append(W3, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "1"*n, 2*dt , -np.pi/2, xgate=True)
+    qc.append(W4, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W5 = Wj_block(3, n-1, "1"*(n-1), dt , -np.pi/2, xgate=[0,1])
+    qc.append(W5, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W6 = Wj_block(1, 1, "0", 2*dt , -np.pi/2, xgate=False)
+    qc.append(W6, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W7 = Wj_block(1+j, 1, "0", -2*dt , -np.pi/2, xgate=[1]*(j-1))
+        qc.append(W7, [blocks[0]]+list(derivatives[n:n+j])+[blocks[1]])
+
+        # qc.barrier()
+
+    W8 = Wj_block(1, n+1, "0"*(n+1), dt , -np.pi/2, xgate=False)
+    qc.append(W8, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W9 = Wj_block(1, n+1, "0"+"1"*(n), -2*dt , -np.pi/2, xgate=False)
+    qc.append(W9, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W10 = Wj_block(2, n, "0"+"1"*(n-1), -dt , -np.pi/2, xgate=False)
+    qc.append(W10, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    # qc.barrier()
+    
+    return qc
+
+def schro(nx, na, R, dt, initial_state, steps):
+
+    nq = int(np.ceil(np.log2(nx)))
+
+    # warped phase transformation
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm1 = np.linalg.norm(fp[2**(na-1):]) # norm of p>=0
+
+    # construct quantum circuit
+    system = QuantumRegister(2*nq+2, name='system')
+    ancilla = QuantumRegister(na, name='ancilla')
+    qc = QuantumCircuit(system, ancilla)
+
+    # initialization
+    prep = StatePreparation(initial_state)
+    anc_prep = StatePreparation(fp / np.linalg.norm(fp))
+
+    qc.append(prep, system)
+    # qc.append(anc_prep, ancilla)
+    qc.initialize(fp / np.linalg.norm(fp), ancilla)
+
+
+    # QFT
+    qc.append(QFTGate(na), ancilla)
+    qc.x(ancilla[-1])
+
+    A1 = V1(nx, dt, name = "V1").to_gate()
+    A2 = V2(nx, dt, name = "V2")
+
+    
+    # Hamiltonian simulation for Nt steps
+    for i in range(steps):
+        # circuit for one step
+        for j in range(na):
+            # repeat controlled H1 for 2**j times
+            qc.append(A1.control().repeat(2**j), [ancilla[j]] + system[:])
+
+        # qc.append(A1.inverse().control(ctrl_state = "0").repeat(2**(na-1)), [ancilla[na-1]] + system[:])
+        qc.append(A1.inverse().repeat(2**(na-1)), system[:])
+        qc.append(A2, system[:])
+
+    # rearrange eta
+    qc.x(ancilla[-1])
+    qc.append(QFTGate(na).inverse(), ancilla)
+
+    return qc
+
+
+
+def circ_for_magnitude(field, x, y, nx, na, R, dt, initial_state, steps):
+
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    index_bin = format(index, f'0{qc.num_qubits-2}b')
+    ctrl_state = '1' + index_bin
+    ctrl_qubits = qc.qubits[:-1]
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state)
+
+    return qc
+
+def circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yref, field_ref = 'Ez'):    
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    if field_ref == 'Ez':
+        index_ref = nx * yref + xref
+    elif field_ref == 'Hx':
+        index_ref = 2*nx*nx + nx * yref + xref
+    else:
+        index_ref = 3*nx*nx + nx * yref + xref
+
+    index_bin = [(index >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_ref_bin = [(index_ref >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_bin.append(1)
+    index_ref_bin.append(1)
+
+    #Convert reference bitstring to 00000 
+    for i, bit in enumerate(index_ref_bin):
+        if bit == 1:
+            qc.x(i)
+
+    d_bits = [b ^ r for b, r in zip(index_ref_bin, index_bin)]
+    control = d_bits.index(1)
+
+    #Convert the other bitstring to 0001000
+    for target, bit in enumerate(d_bits):
+        if bit == 1 and target != control:
+            qc.cx(control, target)
+    qc.h(control)
+
+    ctrl_state_sum = '0'*(qc.num_qubits-1)
+    ctrl_state_diff = '0'*(qc.num_qubits-1-control-1)+'1'+'0'*(control)
+    
+    qcdiff = qc.copy()
+
+    ctrl_qubits = qc.qubits[:-1]
+
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_sum)
+    qcdiff.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_diff)
+
+    return qc, qcdiff
+
+def get_absolute_field_value(qc, nq, na, offset, norm):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator (no parameters needed) ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect = (1 - z_exp) / 2
+
+    Absolute_value = norm*np.sqrt(pi_expect)-offset
+    
+    return Absolute_value
+
+def get_relative_sign(qc, qcdiff, nq, na):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+
+    pub_diff = (qcdiff, observable)
+    job_diff = estimator.run([pub_diff])
+    result_diff = job_diff.result()[0]
+    z_exp_diff = result_diff.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect_sum = (1 - z_exp) / 2
+    pi_expect_diff = (1 - z_exp_diff) / 2
+
+    relative_sign = 'same' if pi_expect_sum >= pi_expect_diff else 'different'
+    
+    return relative_sign
+
+def Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref = 'Ez'):
+    if steps < 31:
+        offset = 1
+    else :
+        offset = 0.15
+    deltastate = np.zeros(4*nx*nx)
+    # deltastate[nx*nx//2+nx//2:nx*nx//2+nx//2+1] = 1
+    deltastate[nx*yref+xref] = 1
+    deltastate[0:nx*nx] = deltastate[0:nx*nx] + offset
+    norm1 = np.linalg.norm(deltastate)
+    initial_state = deltastate/norm1
+
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm2 = np.linalg.norm(fp)
+    norm = norm1 * norm2
+
+    qc = circ_for_magnitude(field_ref, xref, yref, nx, na, R, dt, initial_state, steps)
+
+    Ezref = get_absolute_field_value(qc, nq, na, offset, norm)
+
+    return Ezref
+
+
+def transpile_circ(circ, basis_gates=None):
+    """
+    Transpile the circuit to the specified basis gates.
+    """
+    if basis_gates is None:
+        basis_gates = ['z', 'y', 'x', 'sdg', 's', 'h', 'rz', 'ry', 'rx', 'ecr', 'cz', 'cx']
+    
+    transpiled_circ = transpile(circ, basis_gates=basis_gates)
+    return transpiled_circ
+
+def compute_fidelity(circ1, circ2):
+    
+    circ_1 = tensornetwork_from_circuit(transpile_circ(circ1), simulator_settings)
+    circ_2 = tensornetwork_from_circuit(transpile_circ(circ2), simulator_settings)
+    fidelity = abs(compute_overlap(circ_1, circ_2))**2
+    
+    return fidelity
+
+# def create_impulse_state(grid_dims, impulse_pos):
+#     """
+#     Creates an initial state vector with a single delta impulse at a specified grid position.
+
+#     The 2D grid is flattened into a 1D vector in row-major order, and this
+#     vector is then padded to match the full simulation state space size (4x).
+
+#     Args:
+#         grid_dims (tuple): A tuple (width, height) defining the simulation grid dimensions.
+#                            For your original code, this would be (nx, nx).
+#         impulse_pos (tuple): A tuple (x, y) for the position of the impulse.
+#                              Coordinates are 0-indexed.
+
+#     Returns:
+#         numpy.ndarray: The full, padded initial state vector with a single 1.
+    
+#     Raises:
+#         ValueError: If the impulse position is outside the grid dimensions.
+#     """
+#     grid_width, grid_height = grid_dims
+#     impulse_x, impulse_y = impulse_pos
+
+#     # --- Input Validation ---
+#     # Ensure the requested impulse position is actually on the grid.
+#     if not (0 <= impulse_x < grid_width and 0 <= impulse_y < grid_height):
+#         raise ValueError(f"Impulse position ({impulse_x}, {impulse_y}) is outside the "
+#                          f"grid dimensions ({grid_width}x{grid_height}).")
+
+#     # --- 1. Calculate the 1D Array Index ---
+#     # Convert the (x, y) coordinate to a single index in a flattened 1D array.
+#     # The formula for row-major order is: index = y_coord * width + x_coord
+#     flat_index = impulse_y * grid_width + impulse_x
+
+#     # --- 2. Create the Full, Padded State Vector ---
+#     grid_size = grid_width * grid_height
+#     total_size = 4 * grid_size  # The simulation space is 4x the grid size.
+#     initial_state = np.zeros(total_size)
+
+#     # --- 3. Set the Delta Impulse ---
+#     initial_state[flat_index] = 1
+
+#     return initial_state