IonQ QPU branch is now implemented

em/simulation.py

@@ -792,21 +792,196 @@ async def _run_simulation_async():
             await _flush_async()
         return
 
-    # IonQ QPU placeholder branch (not yet implemented)
-    if state.backend_type == "QPU" and state.selected_qpu == "IonQ QPU":
-        state.error_message = "IonQ QPU backend is not yet available in this build. Please select IBM QPU or the Statevector Estimator."
-        state.status_message = "IonQ QPU backend unavailable."
-        state.status_type = "warning"
-        state.show_progress = False
-        state.is_running = False
-        state.run_button_text = "RUN!"
-        state.stop_button_disabled = True
-        log_to_console("IonQ QPU backend not connected. Use IBM QPU or Statevector Estimator instead.")
-        await _flush_async()
+    # IonQ QPU branch
+    ionq_qpu_selected = state.backend_type == "QPU" and state.selected_qpu == "IonQ QPU"
+    if ionq_qpu_selected:
         try:
-            ctrl.view_update()
-        except Exception:
-            pass
+            log_to_console("Running IonQ QPU simulation...")
+            state.status_message = "Running IonQ QPU simulation..."
+            state.simulation_progress = 5
+            await _flush_async()
+            
+            # Import IonQ QPU backend (same module as IBM, different platform param)
+            try:
+                from quantum.utils.EBU_Quantum.no_body.base_functions import get_field_values as ionq_get_field_values, create_time_frames as ionq_create_time_frames
+            except ModuleNotFoundError:
+                from utils.EBU_Quantum.no_body.base_functions import get_field_values as ionq_get_field_values, create_time_frames as ionq_create_time_frames
+            
+            # Inputs for IonQ QPU (single field, single position only!)
+            snapshot_dt = float(state.dt_user)
+            ix_imp, iy_imp = nearest_node_index(float(state.impulse_x), float(state.impulse_y), nx)
+            impulse_pos = (ix_imp, iy_imp)
+            
+            # Get field and single position from UI
+            field_type = (state.qpu_field_components or "Ez").strip()
+            if field_type == "All":
+                field_type = "Ez"
+                log_to_console("Warning: IonQ QPU only supports single field. Defaulting to Ez.")
+            
+            # Parse single monitor position
+            pts_str = str(state.qpu_monitor_gridpoints or "").strip()
+            raw_pts = [tuple(map(int, m)) for m in re.findall(r"\((\d+)\s*,\s*(\d+)\)", pts_str)]
+            if not raw_pts:
+                monitor_x, monitor_y = impulse_pos
+                log_to_console(f"No monitor position specified. Using impulse position ({monitor_x}, {monitor_y}).")
+            else:
+                monitor_x, monitor_y = raw_pts[0]
+                if len(raw_pts) > 1:
+                    log_to_console(f"Warning: IonQ QPU only supports single position. Using first: ({monitor_x}, {monitor_y})")
+            
+            state.status_message = "Step 1: Generating circuit..."
+            state.simulation_progress = 0
+            await _flush_async()
+            
+            def _ionq_progress_callback(pct, message=None):
+                """Progress callback for IonQ QPU."""
+                state.simulation_progress = int(pct)
+                if message:
+                    state.status_message = message
+                elif pct < 10:
+                    state.status_message = f"Step 1: Generating circuit ({int(pct)}%)"
+                elif pct < 60:
+                    state.status_message = f"Step 2: Optimising circuit ({int(pct)}%)"
+                elif pct < 90:
+                    state.status_message = f"Step 3: Job execution ({int(pct)}%)"
+                else:
+                    state.status_message = f"Step 4: Creating plots ({int(pct)}%)"
+                _flush_state_threadsafe()
+            
+            # Call the IonQ QPU get_field_values function in executor
+            def _run_ionq_qpu():
+                return ionq_get_field_values(
+                    field=field_type,
+                    x=monitor_x,
+                    y=monitor_y,
+                    T=float(T),
+                    snapshot_time=snapshot_dt,
+                    nx=nx,
+                    impulse_pos=impulse_pos,
+                    shots=10000,
+                    pm_optimization_level=1,  # IonQ recommended
+                    simulation="False",
+                    optimization="True",
+                    platform="IONQ",  # <-- Key difference from IBM
+                    progress_callback=_ionq_progress_callback,
+                    print_callback=log_to_console,
+                )
+            
+            field_values = await loop.run_in_executor(executor, _run_ionq_qpu)
+            
+            # Build time frames to match the output
+            times = ionq_create_time_frames(float(T), snapshot_dt)
+            
+            # Build Plotly figure for the single time series
+            import plotly.graph_objects as go
+            fig = go.Figure()
+            
+            # Determine grid dimensions for label
+            if field_type == 'Ez':
+                gw, gh = nx, nx
+            elif field_type == 'Hx':
+                gw, gh = nx, nx - 1
+            else:
+                gw, gh = nx - 1, nx
+            
+            from .utils import normalized_position_label
+            label = normalized_position_label(monitor_x, monitor_y, gw, gh)
+            
+            # Color based on field type
+            if field_type == 'Ez':
+                color = "#d32f2f"
+            elif field_type == 'Hx':
+                color = "#388e3c"
+            else:
+                color = "#1976d2"
+            
+            fig.add_trace(
+                go.Scatter(
+                    x=list(times),
+                    y=[float(v) for v in field_values],
+                    mode='lines+markers',
+                    name=f"{field_type} @ {label}",
+                    line=dict(color=color, width=2.5),
+                    marker=dict(size=7, symbol="circle", color=color),
+                    hovertemplate=f"{field_type} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>{label}</extra>",
+                )
+            )
+            
+            max_abs = max((abs(float(v)) for v in field_values), default=1.0)
+            pad = 0.12 * max_abs if max_abs > 0 else 0.1
+            
+            fig.update_layout(
+                title=f"IonQ QPU Time Series - {field_type} @ {label}",
+                height=660, width=900,
+                margin=dict(l=50, r=30, t=50, b=50),
+                hovermode="x unified",
+                legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, title_text=""),
+                paper_bgcolor="#FFFFFF",
+                plot_bgcolor="#FFFFFF",
+            )
+            fig.update_xaxes(title_text="Time (s)", title_font=dict(size=22), tickfont=dict(size=16), showgrid=True, gridcolor="rgba(0,0,0,.06)")
+            fig.update_yaxes(title_text="Field Value", title_font=dict(size=22), tickfont=dict(size=16), showgrid=True, gridcolor="rgba(0,0,0,.06)")
+            fig.update_yaxes(range=[-max_abs - pad, max_abs + pad])
+            
+            # Cache the figure for export
+            qpu_ts_cache["fig"] = fig
+            qpu_ts_cache["times"] = list(times)
+            qpu_ts_cache["series_map"] = {(field_type, monitor_x, monitor_y): list(field_values)}
+            qpu_ts_cache["field"] = field_type
+            qpu_ts_cache["unique_fields"] = [field_type]
+            
+            try:
+                ctrl.qpu_ts_update(fig)
+            except Exception:
+                pass
+            
+            state.simulation_has_run = True
+            state.run_button_text = "Successful!"
+            state.simulation_progress = 100
+            state.status_message = "IonQ QPU simulation completed successfully!"
+            log_to_console("IonQ QPU run completed")
+            state.status_type = "success"
+            state.show_progress = False
+            _auto_hide_status_window(3.0)
+            await _flush_async()
+            
+            ready = bool(field_values) and len(field_values) > 0
+            state.qpu_ts_ready = ready
+            state.qpu_plot_style = (
+                "width: 900px; height: 660px; margin: 0 auto;"
+                if ready else "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            )
+            state.qpu_ts_other_ready = False
+            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            
+            # Set filter options for single result
+            state.qpu_plot_field_options = ["All", field_type]
+            state.qpu_plot_filter = "All"
+            state.qpu_plot_position_options = ["All positions", label]
+            state.qpu_plot_position_filter = "All positions"
+            
+            if not ready:
+                state.error_message = "No IonQ QPU time series generated. Check Δt, T, nx, and monitor position."
+                state.status_message = "Warning: No IonQ QPU time series generated."
+                state.status_type = "warning"
+            log_to_console("IonQ QPU complete.")
+            
+        except Exception as e:
+            import traceback
+            state.error_message = f"IonQ QPU run failed: {e}"
+            state.status_message = f"IonQ QPU Error: {e}"
+            state.status_type = "error"
+            state.show_progress = False
+            state.run_button_text = "RUN!"
+            state.qpu_ts_ready = False
+            log_to_console(f"IonQ QPU error: {e}")
+            log_to_console(traceback.format_exc())
+        finally:
+            state.is_running = False
+            state.stop_button_disabled = True
+            _stop_progress_heartbeat()
+            executor.shutdown(wait=False)
+            await _flush_async()
         return
 
     # Simulator path - run blocking simulation in executor