Added Console Window

README.md

@@ -36,15 +36,17 @@ individual services so the browser never tries to contact `127.0.0.1` directly.
 ## CUDA-Q backend on CPU-only hosts
 
 The 3D lattice Boltzmann solver relies on CUDA-Q, which expects a CUDA-capable GPU.
-CPU-only runtimes such as Hugging Face Spaces will now automatically skip loading the
-quantum backend so the UI can still boot. Use the following environment variables to
-override the default:
+CPU-only runtimes such as Hugging Face Spaces automatically fall back to a lightweight
+"CPU demo" mode so the UI and preview still run. The plots update with an approximate
+synthetic evolution and clearly indicate the active backend. Use these environment
+variables to control the behavior:
 
 | Variable | Effect |
 | --- | --- |
-| `DISABLE_CUDAQ=1` | Force-disable the CUDA-Q backend regardless of GPU availability. |
+| `DISABLE_CUDAQ=1` | Skip loading the CUDA-Q backend (the CPU demo remains available). |
 | `FORCE_ENABLE_CUDAQ=1` | Attempt to load the CUDA-Q backend even if the platform was auto-detected as CPU-only. |
 
-When the backend is disabled the "Run Simulation" button is greyed out and a warning
-appears in the UI explaining why. Run the app locally on a CUDA-enabled machine and
-set `FORCE_ENABLE_CUDAQ=1` if you still want to attempt a run on a constrained host.
+On GPU-enabled machines, leave both variables unset to run the full CUDA-Q solver. On
+CPU-only hosts you can still explore the workflow in demo mode, or deploy to a GPU-
+backed Space/local workstation and set `FORCE_ENABLE_CUDAQ=1` to activate the quantum
+backend once hardware is available.

em_trame.py

@@ -98,6 +98,7 @@ state.update({
     "qpu_monitor_gridpoints": "", # Derived gridpoints for QPU monitors
     "qpu_monitor_samples": "(0.5, 0.5)",  # User-facing normalized sample input
     "qpu_monitor_sample_info": "",
+    "console_output": "Console initialized.\n",
     # Square aspect for initial preview
     "pyvista_view_style": "aspect-ratio: 1 / 1; width: 100%;",
     "qpu_ts_fig": None,
@@ -139,6 +140,7 @@ state.update({
     "status_type": "info",  # info, success, warning, error
     "simulation_progress": 0,
     "show_progress": False,
+    "console_logs": "Console initialized...\n",
 })
 
 # Ensure hole snap state exists
@@ -724,6 +726,7 @@ def run_simulation_only():
     # Require selections before running
     if not state.geometry_selection:
         state.error_message = "Please select a geometry before running the simulation."
+        log_to_console("Error: Please select a geometry before running.")
         state.status_visible = True
         state.status_message = "Error: Please select a geometry before running."
         state.status_type = "error"
@@ -733,6 +736,7 @@ def run_simulation_only():
         return
     if not state.dist_type:
         state.error_message = "Please select an initial state before running the simulation."
+        log_to_console("Error: Please select an initial state before running.")
         state.status_visible = True
         state.status_message = "Error: Please select an initial state before running."
         state.status_type = "error"
@@ -744,6 +748,7 @@ def run_simulation_only():
     # Show status: Starting simulation
     state.status_visible = True
     state.status_message = "Initializing simulation..."
+    log_to_console("Initializing simulation...")
     state.status_type = "info"
     state.show_progress = True
     state.simulation_progress = 0
@@ -1166,13 +1171,13 @@ def _build_sim_timeseries_plotly(field_type: str, positions, nx: int, times, sim
         )
         fig.update_xaxes(
             title_text="Time (s)", title_font=dict(size=22), tickfont=dict(size=16),
-            showgrid=True, gridcolor="rgba(95,37,159,.08)", zeroline=False,
+            showgrid=True, gridcolor="rgba(95,37,159,0.08)", zeroline=False,
             showline=True, linewidth=1, linecolor="rgba(0,0,0,.2)",
             showspikes=True, spikemode='across', spikesnap='cursor'
         )
         fig.update_yaxes(
             title_text="Field Amplitude", title_font=dict(size=22), tickfont=dict(size=16),
-            showgrid=True, gridcolor="rgba(95,37,159,.08)", zeroline=True, zerolinecolor="rgba(0,0,0,.25)",
+            showgrid=True, gridcolor="rgba(95,37,159,0.08)", zeroline=True, zerolinecolor="rgba(0,0,0,.25)",
             showline=True, linewidth=1, linecolor="rgba(0,0,0,.2)"
         )
         if max_abs > 0:
@@ -1755,6 +1760,20 @@ def handle_file_upload(uploaded_file_info, **kwargs):
         state.upload_status_message = f"File '{file_name}' uploaded."
         state.show_upload_status = True
 
+def log_message(message, level="INFO"):
+    """Append a message to the console log with a timestamp and level."""
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    new_entry = f"[{timestamp}] [{level}] {message}\n"
+    state.console_logs += new_entry
+    # Optional: Limit log size to prevent performance issues
+    if len(state.console_logs) > 50000:
+        state.console_logs = state.console_logs[-50000:]
+
+def log_to_console(message):
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    new_line = f"[{timestamp}] {message}\n"
+    state.console_output = (state.console_output or "") + new_line
+
 def update_excitation_info_message():
     """Calculates and displays the coordinate snapping message."""
     if state.nx is None or state.dist_type is None:
@@ -1852,14 +1871,28 @@ def on_time_change(time_val, **kwargs):
     idx = int(np.argmin(np.abs(times - float(time_val))))
     max_idx = len(data_frames[field]) - 1
     idx = max(0, min(idx, max_idx))
+
     z_data = data_frames[field][idx]
-    if current_mesh.n_points == z_data.size:
-        current_mesh.points[:, 2] = z_data.ravel() * z_scale
-        current_mesh['scalars'] = z_data.ravel()
-        ctrl.view_update()
-    else:
-        redraw_surface_plot()
-    
+    points = np.c_[X_grids[field].ravel(), Y_grids[field].ravel(), z_data.ravel() * z_scale]
+    poly = pv.PolyData(points)
+    mesh = poly.delaunay_2d()
+    mesh['scalars'] = z_data.ravel()
+    current_mesh = mesh
+    plotter.add_mesh(mesh, scalars='scalars', clim=surface_clims[field], cmap="RdBu", show_scalar_bar=False, show_edges=True, edge_color='grey', line_width=0.5)
+    plotter.add_scalar_bar(title=f"{field} Amplitude")
+    try:
+        plotter.disable_picking()
+    except Exception:
+        pass
+    plotter.enable_point_picking(callback=update_value_display, show_message=False)
+    plotter.add_axes()
+    plotter.view_isometric()
+    try:
+        plotter.camera.parallel_projection = True
+    except Exception:
+        pass
+    ctrl.view_update()
+
 def update_value_display(point):
     if current_mesh is None:
         return
@@ -1943,7 +1976,7 @@ def export_vtk_all_frames():
         if snapshot_times is None:
             raise ValueError("Snapshot times are unavailable.")
 
-        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+        dl_dir = os.path.expanduser("~/Downloads")
         suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
         nx = int(state.nx)
         out_dir = os.path.join(dl_dir, f"vtk_sequence_{field}_nx{nx}_{suffix}")
@@ -2151,8 +2184,6 @@ def qpu_set_monitor_field(index, value):
     try:
         i = int(index)
         v = str(value).strip() if value is not None else "Ez"
-        if v not in ("Ez", "Hx", "Hy"):
-            v = "Ez"
         cfgs = list(state.qpu_monitor_configs or [])
         if 0 <= i < len(cfgs):
             cfgs[i]["field"] = v
@@ -2281,8 +2312,8 @@ def _rebuild_qpu_fig_others(selected_field: str, position_filter: str = "All pos
             color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
             fig.add_trace(go.Scatter(
                 x=times, y=ys, mode='lines+markers', name=f"({px}, {py})",
-                line=dict(color=color_hex, width=2.5, dash=dashes[i % len(dashes)]),
-                marker=dict(size=7, symbol=markers[i % len(markers)], color=color_hex),
+                line=dict(color=color_hex, width=2.5, dash=dash_styles[i % len(dash_styles)]),
+                marker=dict(size=7, symbol=marker_symbols[i % len(marker_symbols)], color=color_hex),
                 hovertemplate=f"{sel} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>({px}, {py})</extra>",
             ))
         fig.update_layout(title=f"IBM QPU Time Series (Other components: {sel})", height=660, width=900, margin=dict(l=50, r=30, t=50, b=50), hovermode="x unified", legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, title_text=""))
@@ -2424,8 +2455,7 @@ with SinglePageLayout(server) as layout:
                                     children=["{{ hole_error_message }}"],
                                     classes="mt-1",
                                 )
-                    # Restoring all subsequent input cards
-                    # Cell 4: Excitation
+                    # Cell 3: Excitation
                     with vuetify3.VCard(classes="mb-1", style=("excitation_card_style", "font-size: 0.8rem;")):
                         with vuetify3.VCardTitle("Excitation: Initial State", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
                             pass
@@ -2469,25 +2499,20 @@ with SinglePageLayout(server) as layout:
                                 style="white-space: pre-line;",
                             )
 
-                    # Cell 5: Medium
+                    # Cell 4: Medium
                     with vuetify3.VCard(classes="mb-1", style="font-size: 0.8rem;"):
                         with vuetify3.VCardTitle("Material Properties (Medium)", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
                             pass
                         with vuetify3.VCardText(classes="py-1 px-2"):
                             with vuetify3.VRow(dense=True):
-                                with vuetify3.VCol():
+                                with vuetify3.VCol(cols="6"):
                                     with vuetify3.VTooltip("Relative permittivity. ε_r = ε / ε₀. Default 1.0 (free space).", location="bottom", color="primary"):
                                         with vuetify3.Template(v_slot_activator="{ props }"):
-                                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permittivity", 1.0), label="Relative permittivity (ε_r)", type="number", density="compact", color="primary")
-                                with vuetify3.VCol():
-                                    with vuetify3.VTooltip("Relative permeability. μ_r = μ / μ₀. Typically 1.0 for non-magnetic materials.", location="bottom", color="primary"):
+                                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permittivity", 1.0), label="Permittivity (εr)", type="number", step="0.1", density="compact", color="primary")
+                                with vuetify3.VCol(cols="6"):
+                                    with vuetify3.VTooltip("Relative permeability. μ_r = μ / μ₀. Default 1.0 (non-magnetic).", location="bottom", color="primary"):
                                         with vuetify3.Template(v_slot_activator="{ props }"):
-                                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permeability", 1.0), label="Relative permeability (μ_r)", type="number", density="compact", color="primary")
-
-                    # New Cell: Temporal Settings (moved here)
-                    with vuetify3.VCard(classes="mb-1", style="font-size: 0.8rem;"):
-                        with vuetify3.VCardTitle("Temporal Settings", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
-                            pass
+                                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permeability", 1.0), label="Permeability (μr)", type="number", step="0.1", density="compact", color="primary")
                         with vuetify3.VCardText(classes="py-1 px-2"):
                             with vuetify3.VTooltip("Sets the total duration for the simulation to run.", location="bottom", color="primary"):
                                 with vuetify3.Template(v_slot_activator="{ props }"):
@@ -2766,6 +2791,21 @@ with SinglePageLayout(server) as layout:
                     with vuetify3.VContainer(v_if="!geometry_selection", fluid=True, classes="flex-grow-1 d-flex align-center justify-center text-medium-emphasis"):
                         vuetify3.VCardText("Select a geometry to display the preview and results.")
 
+                    # Console Window
+                    with vuetify3.VCard(classes="mt-2", style="font-size: 0.8rem;"):
+                        with vuetify3.VCardTitle("Console Output", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+                            pass
+                        with vuetify3.VCardText(classes="py-1 px-2", style="height: 150px; overflow-y: auto; background-color: #f5f5f5; font-family: monospace;"):
+                            vuetify3.VTextarea(
+                                v_model=("console_output", ""),
+                                readonly=True,
+                                auto_grow=False,
+                                rows=6,
+                                variant="plain",
+                                hide_details=True,
+                                style="font-family: monospace; width: 100%; height: 100%;"
+                            )
+
         # Status Window - Fixed at bottom right
         with vuetify3.VCard(
             v_if="status_visible",

qlbm.py

@@ -48,6 +48,8 @@ def _should_disable_quantum_backend():
 
 simulate_qlbm_3D_and_animate = None
 _SIMULATION_BACKEND_DISABLED, _SIMULATION_DISABLED_REASON = _should_disable_quantum_backend()
+_CPU_DEMO_AVAILABLE = True
+_CPU_DEMO_MAX_GRID = 48
 
 if not _SIMULATION_BACKEND_DISABLED:
     try:
@@ -69,6 +71,23 @@ _SIMULATION_BACKEND_READY = simulate_qlbm_3D_and_animate is not None
 if not _SIMULATION_BACKEND_READY and _SIMULATION_DISABLED_REASON:
     print(f"Warning: {_SIMULATION_DISABLED_REASON}")
 
+if _SIMULATION_BACKEND_READY:
+    _SIMULATION_BACKEND_NOTE = ""
+    _SIMULATION_MODE_LABEL = "Quantum CUDA-Q backend"
+else:
+    if _CPU_DEMO_AVAILABLE:
+        reason = _SIMULATION_DISABLED_REASON or "Quantum backend is unavailable in this environment."
+        _SIMULATION_BACKEND_NOTE = (
+            f"CPU demo mode active ({reason}). Results are approximate. "
+            "Set FORCE_ENABLE_CUDAQ=1 on a GPU host to use the quantum backend."
+        )
+        _SIMULATION_MODE_LABEL = "CPU demo backend"
+    else:
+        _SIMULATION_BACKEND_NOTE = _SIMULATION_DISABLED_REASON or "Simulation backend unavailable."
+        _SIMULATION_MODE_LABEL = "Unavailable"
+
+_SIMULATION_CAN_RUN = _SIMULATION_BACKEND_READY or _CPU_DEMO_AVAILABLE
+
 # --- Server Setup ---
 server = get_server()
 state, ctrl = server.state, server.controller
@@ -121,8 +140,9 @@ state.update({
     "simulation_has_run": False,
     "time_val": 0,
     "max_time_step": 0,
-    "simulation_backend_ready": _SIMULATION_BACKEND_READY,
-    "simulation_disabled_reason": _SIMULATION_DISABLED_REASON,
+    "simulation_backend_ready": _SIMULATION_CAN_RUN,
+    "simulation_backend_note": _SIMULATION_BACKEND_NOTE,
+    "simulation_backend_mode": _SIMULATION_MODE_LABEL,
     # Workflow guidance styles
     "workflow_step": 0,
     "overview_card_style": _WORKFLOW_BASE_STYLE,
@@ -422,6 +442,84 @@ def make_velocity_func(expr):
             return np.zeros_like(x) if isinstance(x, np.ndarray) else 0.0
     return func
 
+
+def _safe_velocity_sample(func) -> float:
+    try:
+        val = func(0.5, 0.5, 0.5)
+        if isinstance(val, np.ndarray):
+            val = float(np.mean(val))
+        return float(val)
+    except Exception:
+        return 0.0
+
+
+def _cpu_distribution_field(distribution_type: str, Xi, Yi, Zi, grid_size: int, drift, phase_fraction: float):
+    if distribution_type == "Sinusoidal":
+        kx = max(1.0, round(float(state.sine_k_x))) if hasattr(state, "sine_k_x") else 1.0
+        ky = max(1.0, round(float(state.sine_k_y))) if hasattr(state, "sine_k_y") else 1.0
+        kz = max(1.0, round(float(state.sine_k_z))) if hasattr(state, "sine_k_z") else 1.0
+        x_term = np.sin((np.mod(Xi + drift[0], grid_size)) * 2 * np.pi * kx / grid_size)
+        y_term = np.sin((np.mod(Yi + drift[1], grid_size)) * 2 * np.pi * ky / grid_size)
+        z_term = np.sin((np.mod(Zi + drift[2], grid_size)) * 2 * np.pi * kz / grid_size)
+        field = x_term * y_term * z_term + 1.0
+    else:
+        # Gaussian (default fallback)
+        nx_val = max(1.0, float(state.nx)) if hasattr(state, "nx") else float(grid_size)
+        cx = float(state.gauss_cx) if hasattr(state, "gauss_cx") else nx_val / 2
+        cy = float(state.gauss_cy) if hasattr(state, "gauss_cy") else nx_val / 2
+        cz = float(state.gauss_cz) if hasattr(state, "gauss_cz") else nx_val / 2
+        sigma = float(state.gauss_sigma) if hasattr(state, "gauss_sigma") else nx_val / 6
+        scale = (grid_size - 1) / nx_val if nx_val else 1.0
+        cx = cx * scale + drift[0]
+        cy = cy * scale + drift[1]
+        cz = cz * scale + drift[2]
+        sigma = max(1.0, sigma * scale)
+        field = np.exp(-(((Xi - cx) ** 2 + (Yi - cy) ** 2 + (Zi - cz) ** 2) / (2 * sigma ** 2))) * 1.8 + 0.2
+
+    modulation = 0.15 * np.sin(2 * np.pi * phase_fraction + (Xi + Yi + Zi) * np.pi / max(1, grid_size))
+    return field + modulation
+
+
+def _run_cpu_demo_simulation(grid_size: int, T: int, distribution_type: str, vx_func, vy_func, vz_func):
+    grid_size = int(max(8, min(grid_size, _CPU_DEMO_MAX_GRID)))
+    idx_coords = np.linspace(0, grid_size - 1, grid_size, dtype=np.float32)
+    Xi, Yi, Zi = np.meshgrid(idx_coords, idx_coords, idx_coords, indexing='ij')
+    geom_coords = np.linspace(0, 1, grid_size, dtype=np.float32)
+    Xg, Yg, Zg = np.meshgrid(geom_coords, geom_coords, geom_coords, indexing='ij')
+
+    if T <= 0:
+        target = 1.0
+    else:
+        target = float(T)
+    num_frames = min(30, max(2, int(min(target, 20)) + 1))
+    timeline = list(np.linspace(0.0, target, num_frames))
+    if len(timeline) < 2:
+        timeline.append(target)
+
+    vx = _safe_velocity_sample(vx_func)
+    vy = _safe_velocity_sample(vy_func)
+    vz = _safe_velocity_sample(vz_func)
+    drift_scale = 0.25 * grid_size
+
+    frames = []
+    for idx, t_val in enumerate(timeline):
+        phase_fraction = idx / (len(timeline) - 1) if len(timeline) > 1 else 0.0
+        drift = (
+            vx * phase_fraction * drift_scale,
+            vy * phase_fraction * drift_scale,
+            vz * phase_fraction * drift_scale,
+        )
+        field = _cpu_distribution_field(distribution_type, Xi, Yi, Zi, grid_size, drift, phase_fraction)
+        frames.append(field.astype(np.float32))
+
+    grid = pv.StructuredGrid()
+    grid.points = np.column_stack((Xg.ravel(), Yg.ravel(), Zg.ravel()))
+    grid.dimensions = [grid_size, grid_size, grid_size]
+    grid["scalars"] = frames[0].ravel()
+
+    times = [float(t) for t in timeline]
+    return frames, times, grid
+
 def get_geometry_figure():
     """Generates a 3D Plotly figure for the selected geometry."""
     geom = state.geometry_selection
@@ -516,8 +614,8 @@ def update_geometry_view():
 def run_simulation():
     global simulation_data_frames, simulation_times, current_grid_object
     
-    if simulate_qlbm_3D_and_animate is None:
-        state.run_error = _SIMULATION_DISABLED_REASON or "Simulation module is not available on this platform."
+    if not _SIMULATION_CAN_RUN:
+        state.run_error = _SIMULATION_DISABLED_REASON or "Simulation backend is not available on this platform."
         return
 
     state.is_running = True
@@ -537,20 +635,30 @@ def run_simulation():
         vy_func = make_velocity_func(state.vy_expr)
         vz_func = make_velocity_func(state.vz_expr)
         
-        # 2. Run Simulation
-        # Note: simulate_qlbm_3D_and_animate updates the passed plotter with the first frame
-        plotter.clear()
-        _, frames, times, grid_obj = simulate_qlbm_3D_and_animate(
-            num_reg_qubits=num_reg_qubits,
-            T=T,
-            distribution_type=distribution_type,
-            vx_input=vx_func,
-            vy_input=vy_func,
-            vz_input=vz_func,
-            boundary_condition=boundary_condition,
-            plotter=plotter,
-            add_slider=False
-        )
+        if simulate_qlbm_3D_and_animate is not None:
+            # 2a. Run CUDA-Q Simulation
+            plotter.clear()
+            _, frames, times, grid_obj = simulate_qlbm_3D_and_animate(
+                num_reg_qubits=num_reg_qubits,
+                T=T,
+                distribution_type=distribution_type,
+                vx_input=vx_func,
+                vy_input=vy_func,
+                vz_input=vz_func,
+                boundary_condition=boundary_condition,
+                plotter=plotter,
+                add_slider=False
+            )
+        else:
+            # 2b. CPU Demo Simulation (approximate)
+            frames, times, grid_obj = _run_cpu_demo_simulation(
+                grid_size=grid_size,
+                T=T,
+                distribution_type=distribution_type or "Sinusoidal",
+                vx_func=vx_func,
+                vy_func=vy_func,
+                vz_func=vz_func,
+            )
         
         # Force Blues colormap
         if grid_obj:
@@ -1011,12 +1119,13 @@ with SinglePageLayout(server) as layout:
                                 click=run_simulation,
                                 style=("is_running ? '' : 'background-color:#87CEFA;'", ""),
                             )
+                            html.Div("Backend: {{ simulation_backend_mode }}", classes="text-caption text-medium-emphasis mt-2")
                             vuetify3.VAlert(
-                                v_if="simulation_disabled_reason",
-                                type="warning",
+                                v_if="simulation_backend_note",
+                                type="info",
                                 variant="tonal",
                                 density="compact",
-                                children=["{{ simulation_disabled_reason }}"],
+                                children=["{{ simulation_backend_note }}"],
                                 classes="mt-2",
                             )
                             with vuetify3.VRow(dense=True, classes="mt-2"):