EM: IBM QPU Integration

.gitignore

@@ -9,3 +9,6 @@ __pycache__/
 *.pyd
 .Python
 *.so
+
+# Virtual Environments
+**/aqc_venv/

Dockerfile

@@ -49,6 +49,10 @@ RUN python3 -m pip install --upgrade pip setuptools wheel \
 COPY --chown=user:user . .
 COPY docker/nginx.conf /etc/nginx/nginx.conf
 
+# 7. Install the local adapt-aqc package
+# We do this after copying the files so the source code is available
+RUN python3 -m pip install ./utils/adapt-aqc
+
 # Prepare writable directories for nginx (running as non-root later)
 RUN mkdir -p /tmp/nginx/body /tmp/nginx/proxy /tmp/nginx/fastcgi /tmp/nginx/uwsgi /tmp/nginx/scgi \
   && touch /tmp/nginx.access.log /tmp/nginx.error.log \

em/simulation.py

@@ -4,9 +4,10 @@ EM Embedded - Simulation Module
 Contains simulation logic including run_simulation_only, reset_to_defaults,
 and stop handlers.
 """
+import re
 import numpy as np
 
-from .state import state, ctrl, _apply_workflow_highlights, is_statevector_estimator_selected
+from .state import state, ctrl, _apply_workflow_highlights, is_statevector_estimator_selected, is_ibm_qpu_selected
 from .globals import (
     plotter, simulation_data, current_mesh, snapshot_times,
     stop_simulation, qpu_ts_cache, sim_ts_cache, set_stop_simulation, reset_globals
@@ -356,6 +357,7 @@ def run_simulation_only():
                 return qutils.run_sve(
                     field_type,
                     positions,
+                    
                     None,
                     total_time,
                     snapshot_dt,
@@ -420,16 +422,204 @@ 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."
+    # IBM QPU branch
+    ibm_qpu_selected = is_ibm_qpu_selected()
+    if ibm_qpu_selected:
+        try:
+            log_to_console("Running IBM QPU simulation...")
+            state.status_message = "Running IBM QPU simulation..."
+            state.simulation_progress = 5
+            state.qpu_ts_ready = False
+            state.qpu_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            state.qpu_ts_other_ready = False
+            state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
+            
+            # Import IBM QPU backend
+            try:
+                from quantum.utils.EBU_Quantum.no_body.base_functions import get_field_values as ibm_get_field_values, create_time_frames as ibm_create_time_frames
+            except ModuleNotFoundError:
+                from utils.EBU_Quantum.no_body.base_functions import get_field_values as ibm_get_field_values, create_time_frames as ibm_create_time_frames
+            
+            # Inputs for IBM 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
+            # IBM QPU only supports one field and one position!
+            field_type = (state.qpu_field_components or "Ez").strip()
+            if field_type == "All":
+                field_type = "Ez"  # Default to Ez if 'All' selected (not supported by IBM QPU)
+                log_to_console("Warning: IBM 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:
+                # Default to impulse position
+                monitor_x, monitor_y = impulse_pos
+                log_to_console(f"No monitor position specified. Using impulse position ({monitor_x}, {monitor_y}).")
+            else:
+                # Use only the first position (IBM QPU restriction)
+                monitor_x, monitor_y = raw_pts[0]
+                if len(raw_pts) > 1:
+                    log_to_console(f"Warning: IBM QPU only supports single position. Using first: ({monitor_x}, {monitor_y})")
+            
+            state.status_message = "Step 1: Circuit Construction & Optimization (0-40%)..."
+            state.simulation_progress = 10
+            
+            def _ibm_progress_callback(pct):
+                state.simulation_progress = int(pct)
+                # Update status message based on progress stage
+                if pct < 40:
+                    state.status_message = f"Step 1: Circuit Construction & Optimization ({int(pct)}%)"
+                elif pct < 90:
+                    state.status_message = f"Step 2: Circuit Execution ({int(pct)}%)"
+                else:
+                    state.status_message = f"Step 3: Result Processing ({int(pct)}%)"
+            
+            # Call the IBM QPU get_field_values function
+            field_values = ibm_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=2,
+                simulation="False",
+                optimization="False",
+                platform="IBM",
+                progress_callback=_ibm_progress_callback,
+                print_callback=log_to_console,
+            )
+            
+            # Build time frames to match the output
+            times = ibm_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"  # Red
+            elif field_type == 'Hx':
+                color = "#388e3c"  # Green
+            else:
+                color = "#1976d2"  # Blue
+            
+            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"IBM 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 = "IBM QPU simulation completed successfully!"
+            log_to_console("IBM QPU run completed")
+            state.status_type = "success"
+            state.show_progress = False
+            
+            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 IBM QPU time series generated. Check Δt, T, nx, and monitor position."
+                state.status_message = "Warning: No IBM QPU time series generated."
+                state.status_type = "warning"
+            log_to_console("IBM QPU complete.")
+            
+        except Exception as e:
+            import traceback
+            state.error_message = f"IBM QPU run failed: {e}"
+            state.status_message = f"IBM 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"IBM QPU error: {e}")
+            log_to_console(traceback.format_exc())
+        finally:
+            state.is_running = False
+            state.stop_button_disabled = True
+            try:
+                ctrl.view_update()
+            except Exception:
+                pass
+        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("IBM QPU backend not connected. Use the Statevector Estimator simulator instead.")
+        log_to_console("IonQ QPU backend not connected. Use IBM QPU or Statevector Estimator instead.")
         try:
             ctrl.view_update()
         except Exception:

em/state.py

@@ -11,6 +11,7 @@ __all__ = [
     "enable_point_picking_on_plotter",
     "_apply_workflow_highlights", "_determine_workflow_step",
     "is_statevector_estimator_selected",
+    "is_ibm_qpu_selected",
 ]
 
 
@@ -266,6 +267,8 @@ def _init_state_defaults():
         "qpu_plot_field_options": ["All"],
         "qpu_plot_position_filter": "All positions",
         "qpu_plot_position_options": ["All positions"],
+        # IBM QPU specific options (single field only - no "All")
+        "ibm_qpu_field_options": ["Ez", "Hx", "Hy"],
         # Additional QPU monitor slots
         "qpu_monitor_count": 0,
         "qpu_field_components_2": "Ez",
@@ -348,5 +351,15 @@ def is_statevector_estimator_selected() -> bool:
         return False
 
 
+def is_ibm_qpu_selected() -> bool:
+    """Return True when the QPU dropdown targets the IBM QPU."""
+    try:
+        if state.backend_type != "QPU":
+            return False
+        return (state.selected_qpu or "").strip().lower() == "ibm qpu"
+    except AttributeError:
+        return False
+
+
 # Initialize state defaults at module load time
 _init_state_defaults()

em/ui.py

@@ -353,7 +353,7 @@ def _build_meshing_card():
                         density="compact",
                         color="primary",
                     ):
-                        vuetify3.Template(v_slot_thumb_label="{ modelValue }", children=["{{ modelValue === null ? 'Select' : [16, 32, 64, 128, 256, 512][modelValue] }}"])
+                        vuetify3.Template(v_slot_thumb_label="{ modelValue }", children=["{{ modelValue === null ? 'Select' : [8, 16, 32, 64, 128, 256, 512][modelValue] }}"])
                 # Hover content: enlarged Plotly graph
                 with vuetify3.VSheet(classes="pa-2", elevation=6, rounded=True, style="width: 644px;"):
                     qubit_fig_widget = plotly_widgets.Figure(
@@ -414,8 +414,48 @@ def _build_output_preferences_card():
                     vuetify3.VTextField(v_bind="props", v_model=("dt_user", 0.1), label="Δt", type="number", step="0.1", density="compact", color="primary", classes="mt-1")
             vuetify3.VAlert(v_if="temporal_warning", type="warning", variant="tonal", density="compact", children=["{{ temporal_warning }}"], classes="mt-1")
 
-            # QPU monitor options
-            with vuetify3.VContainer(v_if="backend_type === 'QPU' || (backend_type === 'Simulator' && selected_simulator === 'Statevector Estimator')", classes="pa-0 mt-2"):
+            # IBM QPU monitor options (single field, single position ONLY)
+            with vuetify3.VContainer(v_if="backend_type === 'QPU' && selected_qpu === 'IBM QPU'", classes="pa-0 mt-2"):
+                vuetify3.VAlert(
+                    type="info",
+                    variant="tonal",
+                    density="compact",
+                    children=["IBM QPU: Only ONE field component and ONE monitor position supported."],
+                    classes="mb-2",
+                )
+                with vuetify3.VRow(dense=True, classes="mb-1 align-center"):
+                    with vuetify3.VCol(cols=4, sm=3, md=3):
+                        vuetify3.VSelect(
+                            label="Field",
+                            v_model=("qpu_field_components", "Ez"),
+                            items=("ibm_qpu_field_options", ["Ez", "Hx", "Hy"]),
+                            density="compact",
+                            color="primary",
+                            hide_details=True,
+                            style="max-width: 160px;",
+                        )
+                    with vuetify3.VCol(cols=8, sm=9, md=9):
+                        vuetify3.VTextField(
+                            label="Monitor position (x, y) in [0,1]",
+                            v_model=("qpu_monitor_samples", "(0.5, 0.5)"),
+                            density="compact",
+                            color="primary",
+                            hide_details=True,
+                            style="max-width: 320px;",
+                            hint="Single position only for IBM QPU",
+                        )
+                vuetify3.VAlert(
+                    v_if="qpu_monitor_sample_info",
+                    type="info",
+                    variant="tonal",
+                    density="compact",
+                    children=["{{ qpu_monitor_sample_info }}"],
+                    classes="mb-1",
+                    style="white-space: pre-line;",
+                )
+
+            # Statevector Estimator monitor options (supports multiple fields and positions)
+            with vuetify3.VContainer(v_if="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(

requirements.txt

@@ -37,6 +37,7 @@ trame_plotly
 Pillow==10.4.0
 packaging==25.0
 python-dateutil==2.9.0.post0
+pathlib
 
 # Export utilities
 imageio

utils/base_functions.py

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

utils/base_ionq.py

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

utils/delta_impulse_generator.py

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