Refactored the EM backend selection by (1) rebranding the former IBM QPU path into a dedicated Statevector Estimator simulator and (2) rewiring the backend plumbing so the heavy lifting now happens inside

em/excitation.py

@@ -7,7 +7,7 @@ import numpy as np
 import pyvista as pv
 import plotly.graph_objects as go
 
-from .state import state, ctrl
+from .state import state, ctrl, is_statevector_estimator_selected
 from .globals import (
     plotter, current_mesh, DEFAULT_AXIS_TICKS, EXCITATION_SURFACE_COLORSCALE
 )
@@ -352,7 +352,7 @@ def update_qpu_sample_slot(slot_index: int):
     snapped, message = snap_samples_to_grid(sample_value, int(nx_val))
     setattr(state, grid_attr, snapped)
     setattr(state, info_attr, message or "")
-    if state.backend_type == "QPU":
+    if state.backend_type == "QPU" or is_statevector_estimator_selected():
         hide_qpu_plots()
 
 

em/handlers.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import re
 from typing import TYPE_CHECKING
 
-from .state import state, ctrl
+from .state import state, ctrl, is_statevector_estimator_selected
 from .geometry import compute_hole_edges as _compute_hole_edges, update_geometry_hole_preview
 from .excitation import update_initial_state_preview, update_excitation_info_message
 from .qpu import (
@@ -245,7 +245,7 @@ def register_handlers():
 
     @state.change("backend_type")
     def on_backend_change(backend_type, **kwargs):
-        if backend_type == "QPU":
+        if backend_type == "QPU" or (backend_type == "Simulator" and is_statevector_estimator_selected()):
             _hide_qpu_plots()
         _apply_workflow_highlights(_determine_workflow_step())
 
@@ -254,6 +254,11 @@ def register_handlers():
         if state.backend_type == "QPU":
             _hide_qpu_plots()
 
+    @state.change("selected_simulator")
+    def on_selected_simulator_change(selected_simulator, **kwargs):
+        if is_statevector_estimator_selected():
+            _hide_qpu_plots()
+
     @state.change("qpu_plot_filter")
     def on_qpu_plot_filter_change(qpu_plot_filter, **kwargs):
         # No-op: updates handled by controller bound to the VSelect to avoid double refresh
@@ -352,7 +357,7 @@ def register_handlers():
 
         update_excitation_info_message()
 
-        if state.backend_type == "QPU":
+        if state.backend_type == "QPU" or is_statevector_estimator_selected():
             state.qpu_ts_ready = False
             state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
             state.qpu_ts_other_ready = False

em/qpu.py

@@ -15,10 +15,8 @@ from .utils import normalized_position_label, format_grid_label
 
 # Import backend functions
 try:
-    from quantum.utils.delta_impulse_generator import create_time_frames, run_qpu
     import quantum.utils.delta_impulse_generator as qutils
 except ModuleNotFoundError:
-    from utils.delta_impulse_generator import create_time_frames, run_qpu
     import utils.delta_impulse_generator as qutils
 
 __all__ = [
@@ -208,8 +206,10 @@ def refresh_qpu_plot_figures():
         state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
 
 
-def build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt: float, impulse_pos, progress_callback=None, print_callback=None):
-    """Build multi-config Plotly time series for QPU results."""
+def build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt: float, impulse_pos, *, series_runner, progress_callback=None, print_callback=None):
+    """Build multi-config Plotly time series using the provided series runner."""
+    if series_runner is None:
+        raise ValueError("series_runner callable is required for QPU timeseries builds.")
     times = qutils.create_time_frames(T, snapshot_dt)
     fig = go.Figure()
     
@@ -259,12 +259,15 @@ def build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt: f
                 progress_callback(total_p)
 
         try:
-            series_map_field = qutils.run_qpu(
-                field_type, valid_positions, None, 
-                float(T), float(snapshot_dt), int(nx), 
-                None, impulse_pos, 
-                progress_callback=_sub_progress, 
-                print_callback=print_callback
+            series_map_field = series_runner(
+                field_type=field_type,
+                positions=valid_positions,
+                total_time=float(T),
+                snapshot_dt=float(snapshot_dt),
+                nx=int(nx),
+                impulse_pos=impulse_pos,
+                progress_callback=_sub_progress,
+                print_callback=print_callback,
             )
         except Exception as e:
             msg = f"QPU error for {field_type} positions {valid_positions}: {e}"

em/simulation.py

@@ -6,7 +6,7 @@ and stop handlers.
 """
 import numpy as np
 
-from .state import state, ctrl, _apply_workflow_highlights
+from .state import state, ctrl, _apply_workflow_highlights, is_statevector_estimator_selected
 from .globals import (
     plotter, simulation_data, current_mesh, snapshot_times,
     stop_simulation, qpu_ts_cache, sim_ts_cache, set_stop_simulation, reset_globals
@@ -317,11 +317,13 @@ def run_simulation_only():
         state.stop_button_disabled = True
         return
 
-    # If QPU selected, build QPU time series chart and return
-    if state.backend_type == "QPU":
+    sve_selected = is_statevector_estimator_selected()
+
+    # If Statevector Estimator selected, build time series chart and return
+    if sve_selected:
         try:
-            log_to_console("Running QPU...")
-            state.status_message = "Running QPU simulation..."
+            log_to_console("Running Statevector Estimator...")
+            state.status_message = "Running Statevector Estimator simulation..."
             state.simulation_progress = 20
             state.qpu_ts_ready = False
             state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
@@ -347,12 +349,27 @@ def run_simulation_only():
                 p = getattr(state, f"qpu_monitor_gridpoints_{slot_num}", "") or ""
                 configs.append({"field": f, "points": p})
             
-            state.status_message = "Building QPU time series..."
+            state.status_message = "Building Statevector Estimator time series..."
             state.simulation_progress = 60
             
+            def _sve_series_runner(field_type, positions, total_time, snapshot_dt, nx, impulse_pos, progress_callback=None, print_callback=None):
+                return qutils.run_sve(
+                    field_type,
+                    positions,
+                    None,
+                    total_time,
+                    snapshot_dt,
+                    nx,
+                    None,
+                    impulse_pos,
+                    progress_callback=progress_callback,
+                    print_callback=print_callback,
+                )
+
             # Build and render Plotly chart
             fig = build_qpu_timeseries_plotly_multi(
-                configs, nx, T, snapshot_dt, impulse_pos, 
+                configs, nx, T, snapshot_dt, impulse_pos,
+                series_runner=_sve_series_runner,
                 progress_callback=_progress_callback, 
                 print_callback=log_to_console
             )
@@ -366,8 +383,8 @@ def run_simulation_only():
             state.simulation_has_run = True
             state.run_button_text = "Successful!"
             state.simulation_progress = 100
-            state.status_message = "QPU simulation completed successfully!"
-            log_to_console("Simulation Completed")
+            state.status_message = "Statevector Estimator simulation completed successfully!"
+            log_to_console("Statevector Estimator run completed")
             state.status_type = "success"
             state.show_progress = False
             
@@ -381,19 +398,19 @@ def run_simulation_only():
             state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
             
             if not ready:
-                state.error_message = "No QPU time series generated. Check Δt, T, nx, and monitor points."
-                state.status_message = "Warning: No QPU time series generated."
+                state.error_message = "No Statevector Estimator time series generated. Check Δt, T, nx, and monitor points."
+                state.status_message = "Warning: No Statevector Estimator time series generated."
                 state.status_type = "warning"
-            log_to_console("QPU complete.")
+            log_to_console("Statevector Estimator complete.")
             
         except Exception as e:
-            state.error_message = f"QPU run failed: {e}"
-            state.status_message = f"QPU Error: {e}"
+            state.error_message = f"Statevector Estimator run failed: {e}"
+            state.status_message = f"Statevector Estimator Error: {e}"
             state.status_type = "error"
             state.show_progress = False
             state.run_button_text = "RUN!"
             state.qpu_ts_ready = False
-            log_to_console(f"QPU error: {e}")
+            log_to_console(f"Statevector Estimator error: {e}")
         finally:
             state.is_running = False
             state.stop_button_disabled = True
@@ -403,6 +420,22 @@ def run_simulation_only():
                 pass
         return
 
+    # IBM QPU placeholder branch
+    if state.backend_type == "QPU":
+        state.error_message = "IBM QPU backend is not yet available in this build. Please select the Statevector Estimator from the Simulator menu."
+        state.status_message = "IBM 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("IBM QPU backend not connected. Use the Statevector Estimator simulator instead.")
+        try:
+            ctrl.view_update()
+        except Exception:
+            pass
+        return
+
     # Simulator path
     log_to_console("Running simulation...")
     state.status_message = "Running simulation... This may take a while."

em/state.py

@@ -10,6 +10,7 @@ __all__ = [
     "state", "ctrl", "set_server", "init_state",
     "enable_point_picking_on_plotter",
     "_apply_workflow_highlights", "_determine_workflow_step",
+    "is_statevector_estimator_selected",
 ]
 
 
@@ -337,5 +338,15 @@ def enable_point_picking_on_plotter():
         pass
 
 
+def is_statevector_estimator_selected() -> bool:
+    """Return True when the simulator dropdown targets the Statevector Estimator."""
+    try:
+        if state.backend_type != "Simulator":
+            return False
+        return (state.selected_simulator or "").strip().lower() == "statevector estimator"
+    except AttributeError:
+        return False
+
+
 # Initialize state defaults at module load time
 _init_state_defaults()

em/ui.py

@@ -404,6 +404,7 @@ def _build_backends_card():
                             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="Statevector Estimator", click="backend_type = 'Simulator'; selected_simulator = 'Statevector Estimator'")
                     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")
@@ -425,7 +426,7 @@ def _build_output_preferences_card():
             vuetify3.VAlert(v_if="temporal_warning", type="warning", variant="tonal", density="compact", children=["{{ temporal_warning }}"], classes="mt-1")
 
             # QPU monitor options
-            with vuetify3.VContainer(v_if="backend_type === 'QPU'", classes="pa-0 mt-2"):
+            with vuetify3.VContainer(v_if="backend_type === 'QPU' || (backend_type === 'Simulator' && selected_simulator === 'Statevector Estimator')", classes="pa-0 mt-2"):
                 with vuetify3.VRow(dense=True, classes="mb-1 align-center"):
                     with vuetify3.VCol(cols=4, sm=3, md=3):
                         vuetify3.VSelect(
@@ -500,7 +501,7 @@ def _build_reset_button():
 
 def _build_output_config_card():
     """Build the Output Configuration card (appears after simulation, not for QPU)."""
-    with vuetify3.VCard(v_if="simulation_has_run && backend_type !== 'QPU'", classes="mb-1", style="font-size: 0.8rem;"):
+    with vuetify3.VCard(v_if="simulation_has_run && backend_type !== 'QPU' && !(backend_type === 'Simulator' && selected_simulator === 'Statevector Estimator')", classes="mb-1", style="font-size: 0.8rem;"):
         with vuetify3.VCardSubtitle("Output Configuration", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px; font-weight: 600; color: #1A1A1A;"):
             with vuetify3.VCardText(classes="py-1 px-2", style="color: #1A1A1A;"):
                 with vuetify3.VRadioGroup(v_model=("output_type", "Surface Plot"), row=True, density="compact", color="primary"):
@@ -553,7 +554,7 @@ def _build_output_config_card():
 def _build_main_plot_area():
     """Build the main plot area (PyVista for Simulator)."""
     with vuetify3.VCard(
-        v_if="geometry_selection && (backend_type !== 'QPU' || !qpu_ts_ready)",
+        v_if="geometry_selection && ((backend_type !== 'QPU' && !(backend_type === 'Simulator' && selected_simulator === 'Statevector Estimator')) || !qpu_ts_ready)",
         classes="mb-1 flex-grow-1 d-flex flex-column",
         style="min-height: 0;",
     ):
@@ -605,17 +606,17 @@ def _build_main_plot_area():
             ctrl.sim_ts_update = sim_ts.update
         
         # Time slider for surface plot
-        with vuetify3.VContainer(v_if="simulation_has_run && output_type === 'Surface Plot' && backend_type !== 'QPU'", fluid=True, classes="pa-0 mt-2"):
+        with vuetify3.VContainer(v_if="simulation_has_run && output_type === 'Surface Plot' && backend_type !== 'QPU' && !(backend_type === 'Simulator' && selected_simulator === 'Statevector Estimator')", fluid=True, classes="pa-0 mt-2"):
             vuetify3.VSlider(v_model=("time_val", 0.0), label="Time", min=0, max=("T", 10.0), step=("dt_user", 0.1), thumb_label="always", density="compact", color="primary")
 
 
 def _build_qpu_plot_area():
     """Build the QPU plot area (Plotly time series)."""
-    with vuetify3.VCard(v_if="geometry_selection && backend_type === 'QPU' && (is_running || qpu_ts_ready)", classes="flex-grow-1", style="min-height: 0;"):
+    with vuetify3.VCard(v_if="geometry_selection && (backend_type === 'QPU' || (backend_type === 'Simulator' && selected_simulator === 'Statevector Estimator')) && (is_running || qpu_ts_ready)", classes="flex-grow-1", style="min-height: 0;"):
         # Running indicator
         with vuetify3.VContainer(v_if="is_running", fluid=True, classes="fill-height d-flex flex-column align-center justify-center"):
             vuetify3.VProgressCircular(indeterminate=True, size=64, color="primary")
-            vuetify3.VCardSubtitle("Running QPU...", classes="mt-4")
+            vuetify3.VCardSubtitle("Running {{ backend_type === 'QPU' ? selected_qpu : selected_simulator }}...", classes="mt-4")
         
         # QPU timeseries with toolbar
         with vuetify3.VContainer(v_if="!is_running && qpu_ts_ready", fluid=True, classes="pa-2"):

em_embedded.py

@@ -581,7 +581,7 @@ def _build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt:
 
         # Fetch time series from QPU for this field and the validated positions
         try:
-            series_map_field = qutils.run_qpu(field_type, valid_positions, None, float(T), float(snapshot_dt), int(nx), None, impulse_pos, progress_callback=_sub_progress, print_callback=print_callback)
+            series_map_field = qutils.run_sve(field_type, valid_positions, None, float(T), float(snapshot_dt), int(nx), None, impulse_pos, progress_callback=_sub_progress, print_callback=print_callback)
         except Exception as e:
             msg = f"QPU error for {field_type} positions {valid_positions}: {e}"
             if print_callback:

qlbm/qlbm_sample_app.py

@@ -873,20 +873,11 @@ def show_initial_distribution(
 if __name__=="__main__":
 
   n=3
-  # plot = show_initial_distribution(
-  #     n=n,
-  #     init_state_name="sin",
-  #     sine_k_x=1.0,
-  #     sine_k_y=1.0,
-  #     sine_k_z=1.0,
-  #     plot=True,
-  #     return_data=False
-  # )
-  
-  # Step 1: Create the initial state circuit ONCE with all parameters
+
+  # # Step 1: Create the initial state circuit ONCE with all parameters
   init_state_prep_circ = get_named_init_state_circuit(
       n=n,
-      init_state_name="gaussian",  # or "gaussian", "dirac_delta"
+      init_state_name="sin",  # or "gaussian", "dirac_delta"
       sine_k_x=1.0,
       sine_k_y=1.0,
       sine_k_z=1.0
@@ -896,36 +887,36 @@ if __name__=="__main__":
       # gauss_sigma=0.2,
   )
   
-    # Alternative: Run on local simulator
-  output, fig = run_sampling_sim(
-      n=n,
-      ux="sin(2*pi*y)*sin(2*pi*z)",
-      uy="sin(2*pi*x)*sin(2*pi*z)",
-      uz="sin(2*pi*x)*sin(2*pi*y)",
-      init_state_prep_circ=init_state_prep_circ,
-      T_list=[1,3,5],
-      vel_resolution=2
-  )
-  fig.show()
+  #   # Alternative: Run on local simulator
+  # output, fig = run_sampling_sim(
+  #     n=n,
+  #     ux="sin(2*pi*y)*sin(2*pi*z)",
+  #     uy="sin(2*pi*x)*sin(2*pi*z)",
+  #     uz="sin(2*pi*x)*sin(2*pi*y)",
+  #     init_state_prep_circ=init_state_prep_circ,
+  #     T_list=[1,3,5],
+  #     vel_resolution=2
+  # )
+  # fig.show()
 
   # Step 2: (Optional) Preview the initial distribution
   # show_initial_distribution(n=n, init_state_name="sin", sine_k_x=1, sine_k_y=1, sine_k_z=1)
 
   # Step 3: Run simulation - pass the pre-built circuit
-  # job, get_job_result = run_sampling_hw_ibm(
-  #     n=n,
-  #     ux=lambda x,y,z: 1,
-  #     uy=lambda x,y,z: 1,
-  #     uz=lambda x,y,z: 1,
-  #     init_state_prep_circ=init_state_prep_circ,  # Pass the circuit directly
-  #     T_list=[1],
-  #     shots=2**19,
-  #     vel_resolution=2,
-  # )
+  job, get_job_result = run_sampling_hw_ibm(
+      n=n,
+      ux=lambda x,y,z: 1,
+      uy=lambda x,y,z: 1,
+      uz=lambda x,y,z: 1,
+      init_state_prep_circ=init_state_prep_circ,  # Pass the circuit directly
+      T_list=[1],
+      shots=2**19,
+      vel_resolution=2,
+  )
 
-  # output = get_job_result(job)
-  # for xx, yy, zz, dens in output:
-  #   plot_density_isosurface(xx, yy, zz, dens)
+  output = get_job_result(job)
+  for xx, yy, zz, dens in output:
+    plot_density_isosurface(xx, yy, zz, dens)
 
 
 

utils/delta_impulse_generator.py

@@ -375,7 +375,7 @@ def create_impulse_preview_state(preview_n: int, pos01, sigma01: float = 0.02):
 
 
 
-##### IBM QPU Simulation Code Below (Do Not Edit) #####
+##### Statevector Estimator Simulation Code Below #####
 
 from .base_functions import * 
 
@@ -412,9 +412,10 @@ def create_time_frames(total_time, snapshot_interval):
 
 
 
-def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos, progress_callback=None, print_callback=None):
-    """
-    Compute time-series field values. Supports single-point and multi-point modes.
+def run_sve(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos, progress_callback=None, print_callback=None):
+    """Statevector Estimator for time-series field values.
+
+    Supports both single-point and multi-point modes.
 
     - Single-point (backward compatible): x, y are integers; returns list[float].
     - Multi-point: x is a list/tuple of (ix, iy) integer pairs and y is None; returns dict[(ix,iy) -> list[float]].
@@ -487,6 +488,6 @@ def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos, progr
         if progress_callback:
             progress_callback((idx + 1) / total_frames * 100)
     
-    _log("QPU simulation completed.")
+        _log("Statevector Estimator simulation completed.")
 
     return series_by_point if multi else series_single