Add detailed progress tracking for IBM QPU

em/simulation.py

@@ -451,8 +451,8 @@ async def _run_simulation_async():
     if sve_selected:
         try:
             log_to_console("Running Statevector Estimator...")
-            state.status_message = "Running Statevector Estimator simulation..."
-            state.simulation_progress = 20
+            state.status_message = "Step 1: Initializing Statevector Estimator..."
+            state.simulation_progress = 5
             await _flush_async()
             
             state.qpu_ts_ready = False
@@ -479,10 +479,24 @@ async def _run_simulation_async():
                 p = getattr(state, f"qpu_monitor_gridpoints_{slot_num}", "") or ""
                 configs.append({"field": f, "points": p})
             
-            state.status_message = "Building Statevector Estimator time series..."
-            state.simulation_progress = 60
+            state.status_message = "Step 1: Setting up Statevector Estimator..."
+            state.simulation_progress = 10
             await _flush_async()
             
+            # SVE-specific progress callback that maps internal 0-100% to 10-90% range
+            # and shows appropriate step messages
+            def _sve_progress_callback(pct):
+                # Map internal progress (0-100%) to range 10-90%
+                mapped_pct = 10 + (pct * 0.8)  # 10% to 90%
+                state.simulation_progress = int(mapped_pct)
+                if mapped_pct < 30:
+                    state.status_message = f"Step 2: Building quantum circuits ({int(mapped_pct)}%)"
+                elif mapped_pct < 70:
+                    state.status_message = f"Step 3: Running Statevector simulation ({int(mapped_pct)}%)"
+                else:
+                    state.status_message = f"Step 4: Processing results ({int(mapped_pct)}%)"
+                _flush_state_threadsafe()
+            
             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,
@@ -503,13 +517,18 @@ async def _run_simulation_async():
                 return build_qpu_timeseries_plotly_multi(
                     configs, nx, T, snapshot_dt, impulse_pos,
                     series_runner=_sve_series_runner,
-                    progress_callback=_progress_callback, 
+                    progress_callback=_sve_progress_callback, 
                     print_callback=log_to_console
                 )
             
             fig = await loop.run_in_executor(executor, _run_sve_blocking)
             qpu_ts_cache["fig"] = fig
             
+            # Step 5: Creating plots (90-100%)
+            state.simulation_progress = 95
+            state.status_message = "Step 5: Creating plots (95%)"
+            _flush_state()
+            
             try:
                 ctrl.qpu_ts_update(fig)
             except Exception:
@@ -594,18 +613,31 @@ async def _run_simulation_async():
                 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
+            state.status_message = "Step 1: Generating circuit..."
+            state.simulation_progress = 0
             await _flush_async()
             
-            def _ibm_progress_callback(pct):
+            def _ibm_progress_callback(pct, message=None):
+                """
+                Progress callback for IBM QPU with 4-step pattern:
+                Step 1: Generating circuit (0-10%)
+                Step 2: Optimising Circuit (10-60%)
+                Step 3: Job Submitted + Status monitoring (60-90%)
+                Step 4: Creating Plots (90-100%)
+                """
                 state.simulation_progress = int(pct)
-                if pct < 40:
-                    state.status_message = f"Step 1: Circuit Construction & Optimization ({int(pct)}%)"
+                
+                if message:
+                    state.status_message = message
+                elif pct < 10:
+                    state.status_message = f"Step 1: Generating circuit ({int(pct)}%)"
+                elif pct < 60:
+                    # Map 10-40% internal to 10-60% display
+                    state.status_message = f"Step 2: Optimising circuit ({int(pct)}%)"
                 elif pct < 90:
-                    state.status_message = f"Step 2: Circuit Execution ({int(pct)}%)"
+                    state.status_message = f"Step 3: Job execution ({int(pct)}%)"
                 else:
-                    state.status_message = f"Step 3: Result Processing ({int(pct)}%)"
+                    state.status_message = f"Step 4: Creating plots ({int(pct)}%)"
                 _flush_state_threadsafe()  # Thread-safe flush from callback thread
             
             # Call the IBM QPU get_field_values function in executor to keep UI responsive

qlbm/qlbm_sample_app.py

@@ -513,7 +513,8 @@ def run_sampling_hw_ibm(
     vel_resolution=32,
     output_resolution=40,
     logger=None,
-    flag_qubits=True
+    flag_qubits=True,
+    progress_callback=None,
 ):
   """
   Run QLBM simulation on IBM quantum hardware.
@@ -536,6 +537,8 @@ def run_sampling_hw_ibm(
       Grid resolution for density estimation output
   logger : callable, optional
       Function to log messages (e.g. print to console)
+  progress_callback : callable, optional
+      Function to report progress (0-100) with optional status message: progress_callback(percent, message)
   
   Returns
   -------
@@ -544,6 +547,7 @@ def run_sampling_hw_ibm(
   get_job_result : callable
       Callback function to retrieve and process results. Returns (output, fig).
   """
+  import time as time_module
 
   def log(msg):
       if logger:
@@ -551,62 +555,144 @@ def run_sampling_hw_ibm(
       else:
           print(msg)
 
-  # if type(ux)==str:
-  #   ux,uy,uz=str_to_lambda(ux,uy,uz)
+  def update_progress(percent, message=None):
+      if progress_callback:
+          progress_callback(percent, message)
 
-  # # Convert string init_state_prep_circ to circuit if needed (matches original logic)
-  # if type(init_state_prep_circ)==str:
-  #   init_state_prep_circ=get_named_init_state_circuit(n,init_state_prep_circ)
+  # === STEP 1: Circuit Generation (0-50%) ===
+  log("Step 1: Generating quantum circuits...")
+  update_progress(5, "Generating quantum circuits...")
 
   qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution,flag_qubits=flag_qubits)
+  
+  log(f"Generated {len(qc_list)} circuit(s) for timesteps {T_list}")
+  update_progress(15, f"Generated {len(qc_list)} circuits")
 
   pm_optimization_level = 3
 
-  service = QiskitRuntimeService(channel="ibm_cloud", token="UMeZUDI5D7fjPJHD5x3MJFwURg4PrGzBnTm142ka9-Hj",instance="crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::")         # reads stored credentials / environment
+  log("Connecting to IBM Quantum service...")
+  update_progress(20, "Connecting to IBM Quantum...")
+  
+  service = QiskitRuntimeService(channel="ibm_cloud", token="UMeZUDI5D7fjPJHD5x3MJFwURg4PrGzBnTm142ka9-Hj",instance="crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::")
   backend = service.least_busy()
+  log(f"Selected backend: {backend.name}")
+  update_progress(25, f"Backend: {backend.name}")
 
   qc_compiled_list=[]
+  total_circuits = len(qc_list)
 
-  for qc in qc_list:
+  for idx, qc in enumerate(qc_list):
+    circuit_progress = 25 + (idx / total_circuits) * 20  # 25-45%
+    update_progress(circuit_progress, f"Transpiling circuit {idx+1}/{total_circuits}...")
+    
     pm = generate_preset_pass_manager(backend=backend, optimization_level=pm_optimization_level)
-    log("Generating ISA circuit via PassManager (preserves measurements/conditionals).")
-    qc_compiled = pm.run(qc)   # this is the recommended replacement for transpile(..., backend=backend)
-    log(f"Compiled circuit qubits/clbits: {qc_compiled.num_qubits} {qc_compiled.num_clbits}")
-    log(f"Depth: {qc_compiled.depth()}")
+    log(f"Transpiling circuit {idx+1}/{total_circuits} via PassManager...")
+    qc_compiled = pm.run(qc)
+    log(f"  Compiled: {qc_compiled.num_qubits} qubits, {qc_compiled.num_clbits} clbits, depth={qc_compiled.depth()}")
     qc_compiled_list+=[qc_compiled]
 
-  # Create Sampler primitive bound to the backend
-  sampler = Sampler(mode=backend)
+  log("All circuits transpiled successfully.")
+  update_progress(50, "Circuits ready. Submitting job...")
 
-  # # Submit job: pass a list of PUBs (we send one PUB [qc_compiled])
+  # === STEP 2: Job Submission & Monitoring (50-90%) ===
+  sampler = Sampler(mode=backend)
   job = sampler.run(qc_compiled_list, shots=shots)
-  log("Job submitted; waiting for result...")
+  job_id = job.job_id() if hasattr(job, 'job_id') else str(job)
+  log(f"Job submitted! Job ID: {job_id}")
+  update_progress(52, f"Job submitted: {job_id}")
 
   def get_job_result(j):
-    result = j.result()   # PrimitiveResult (a container of PubResults)
-    log("Waiting for job results (this may take time)...")
+    """Poll job status and retrieve results with progress updates."""
+    # Job status polling with progress updates
+    log("Monitoring job status...")
+    update_progress(55, "Job queued, waiting for execution...")
+    
+    # Status mapping for progress estimation
+    # JobStatus: INITIALIZING, QUEUED, VALIDATING, RUNNING, CANCELLED, DONE, ERROR
+    status_progress_map = {
+        'INITIALIZING': (55, "Job initializing..."),
+        'QUEUED': (58, "Job queued, waiting..."),
+        'VALIDATING': (62, "Validating job..."),
+        'RUNNING': (70, "Job running on QPU..."),
+        'DONE': (85, "Job completed!"),
+        'ERROR': (85, "Job error occurred"),
+        'CANCELLED': (85, "Job cancelled"),
+    }
+    
+    last_status = None
+    poll_count = 0
+    max_polls = 600  # ~10 minutes with 1s interval
+    
+    while poll_count < max_polls:
+      try:
+        status = j.status()
+        status_name = status.name if hasattr(status, 'name') else str(status)
+        
+        if status_name != last_status:
+          last_status = status_name
+          progress_val, status_msg = status_progress_map.get(status_name, (60, f"Status: {status_name}"))
+          log(f"Job Status: {status_name}")
+          update_progress(progress_val, status_msg)
+        
+        # Check if job is complete
+        if status_name in ('DONE', 'ERROR', 'CANCELLED'):
+          break
+        
+        # Increment progress slightly while waiting (indeterminate feel)
+        if status_name == 'QUEUED':
+          # Slowly increment between 58-65 while queued
+          queue_progress = 58 + min(7, poll_count * 0.05)
+          update_progress(queue_progress, f"Queued... (waiting {poll_count}s)")
+        elif status_name == 'RUNNING':
+          # Slowly increment between 70-85 while running
+          run_progress = 70 + min(15, poll_count * 0.1)
+          update_progress(run_progress, f"Running on QPU... ({poll_count}s)")
+        
+        time_module.sleep(1)
+        poll_count += 1
+        
+      except Exception as e:
+        log(f"Status check error: {e}")
+        time_module.sleep(2)
+        poll_count += 2
+    
+    # Get results
+    log("Retrieving job results...")
+    update_progress(87, "Retrieving results...")
+    
+    result = j.result()
+    log("Results retrieved successfully.")
+    update_progress(90, "Processing results...")
 
+    # === STEP 3: Creating Plots (90-100%) ===
     output=[]
+    total_timesteps = len(T_list)
 
-    for T_total,pub in zip(T_list,result):
+    for idx, (T_total, pub) in enumerate(zip(T_list, result)):
+      plot_progress = 90 + (idx / total_timesteps) * 8  # 90-98%
+      update_progress(plot_progress, f"Processing timestep T={T_total}...")
 
-      # Try join_data() to combine multiple regs and get_counts() on it
       try:
-          joined = pub.join_data()    # join_data concatenates registers along bits axis
+          joined = pub.join_data()
           joined_counts = joined.get_counts()
       except Exception as e:
-          log(f"Error retrieving counts: {e}")
+          log(f"Error retrieving counts for T={T_total}: {e}")
           joined_counts = None
 
-      # Suppress verbose logging by passing None as logger
       pts, counts = load_samples(joined_counts, T_total, logger=None, flag_qubits=flag_qubits)
       output+=[estimate_density(pts, counts, bandwidth=0.05, grid_size=output_resolution)]
 
     log(f"Processing complete: {len(output)} timestep(s)")
+    update_progress(98, "Creating visualization...")
+    
     fig = plot_density_isosurface_slider(output, T_list)
+    
+    update_progress(100, "Complete!")
+    log("IBM QPU job completed successfully.")
+    
     return output, fig
   
-  return job,get_job_result
+  return job, get_job_result
 
 from qiskit_ionq import IonQProvider
 
@@ -623,7 +709,8 @@ def run_sampling_hw_ionq(
     vel_resolution=32,
     output_resolution=40,
     logger=None,
-    flag_qubits=True
+    flag_qubits=True,
+    progress_callback=None,
 ):
   """
   Run QLBM simulation on IonQ quantum hardware.
@@ -646,6 +733,8 @@ def run_sampling_hw_ionq(
       Grid resolution for density estimation output
   logger : callable, optional
       Function to log messages (e.g. print to console)
+  progress_callback : callable, optional
+      Function to report progress (0-100) with optional status message: progress_callback(percent, message)
   
   Returns
   -------
@@ -654,6 +743,7 @@ def run_sampling_hw_ionq(
   get_job_result : callable
       Callback function to retrieve and process results. Returns (output, fig).
   """
+  import time as time_module
 
   def log(msg):
       if logger:
@@ -661,49 +751,110 @@ def run_sampling_hw_ionq(
       else:
           print(msg)
 
-  # if type(ux)==str:
-  #   ux,uy,uz=str_to_lambda(ux,uy,uz)
+  def update_progress(percent, message=None):
+      if progress_callback:
+          progress_callback(percent, message)
 
-  # # Convert string init_state_prep_circ to circuit if needed (matches original logic)
-  # if type(init_state_prep_circ)==str:
-  #   init_state_prep_circ=get_named_init_state_circuit(n,init_state_prep_circ)
+  # === STEP 1: Circuit Generation (0-50%) ===
+  log("Step 1: Generating quantum circuits...")
+  update_progress(5, "Generating quantum circuits...")
 
   # backend = provider.get_backend("simulator")
   backend = provider.get_backend("qpu.forte-enterprise-1")
+  log(f"Selected IonQ backend: {backend.name()}")
+  update_progress(15, f"Backend: {backend.name()}")
 
   qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution,flag_qubits=flag_qubits,midcircuit_meas=False)
+  
+  log(f"Generated {len(qc_list)} circuit(s) for timesteps {T_list}")
+  update_progress(45, f"Generated {len(qc_list)} circuits")
 
-  # Create Sampler primitive bound to the backend
+  # === STEP 2: Job Submission (50%) ===
+  log("Submitting job to IonQ...")
+  update_progress(50, "Submitting job to IonQ...")
 
   job = backend.run(qc_list, shots=shots)
-
-  # job = backend.retrieve_job("019b0aec-36d7-749a-89f2-c36382b3aa1c")
-
-  # sampler = Sampler(mode=backend)
-
-  # # Submit job: pass a list of PUBs (we send one PUB [qc_compiled])
-  # job = sampler.run(qc_compiled_list, shots=shots)
-  log("Job submitted; waiting for result...")
+  job_id = job.job_id() if hasattr(job, 'job_id') else str(job)
+  log(f"Job submitted! Job ID: {job_id}")
+  update_progress(52, f"Job submitted: {job_id}")
 
   def get_job_result(j):
+    """Poll job status and retrieve results with progress updates."""
+    log("Monitoring IonQ job status...")
+    update_progress(55, "Job queued, waiting for execution...")
+    
+    # IonQ job status polling
+    last_status = None
+    poll_count = 0
+    max_polls = 600  # ~10 minutes with 1s interval
     
-    log("Waiting for job results (this may take time)...")
+    while poll_count < max_polls:
+      try:
+        status = j.status()
+        status_name = status.name if hasattr(status, 'name') else str(status)
+        
+        if status_name != last_status:
+          last_status = status_name
+          log(f"Job Status: {status_name}")
+          
+          if status_name in ('QUEUED', 'VALIDATING'):
+            update_progress(58, f"Status: {status_name}")
+          elif status_name == 'RUNNING':
+            update_progress(70, "Job running on IonQ QPU...")
+          elif status_name == 'DONE':
+            update_progress(85, "Job completed!")
+            break
+          elif status_name in ('ERROR', 'CANCELLED'):
+            update_progress(85, f"Job {status_name.lower()}")
+            break
+        
+        # Increment progress slightly while waiting
+        if status_name == 'QUEUED':
+          queue_progress = 58 + min(7, poll_count * 0.05)
+          update_progress(queue_progress, f"Queued... (waiting {poll_count}s)")
+        elif status_name == 'RUNNING':
+          run_progress = 70 + min(15, poll_count * 0.1)
+          update_progress(run_progress, f"Running on IonQ... ({poll_count}s)")
+        
+        # Check if done
+        if status_name in ('DONE', 'ERROR', 'CANCELLED'):
+          break
+        
+        time_module.sleep(1)
+        poll_count += 1
+        
+      except Exception as e:
+        log(f"Status check error: {e}")
+        time_module.sleep(2)
+        poll_count += 2
+    
+    log("Retrieving IonQ job results...")
+    update_progress(87, "Retrieving results...")
 
+    # === STEP 3: Creating Plots (90-100%) ===
+    update_progress(90, "Processing results...")
     output=[]
+    total_timesteps = len(T_list)
 
-    for i,T_total in enumerate(T_list):
+    for i, T_total in enumerate(T_list):
+      plot_progress = 90 + (i / total_timesteps) * 8  # 90-98%
+      update_progress(plot_progress, f"Processing timestep T={T_total}...")
 
       counts = j.get_counts(i)
-
-      # Suppress verbose logging by passing None as logger
       pts, counts = load_samples(counts, T_total, logger=None, flag_qubits=flag_qubits, midcircuit_meas=False)
       output+=[estimate_density(pts, counts, bandwidth=0.05, grid_size=output_resolution)]
 
     log(f"Processing complete: {len(output)} timestep(s)")
+    update_progress(98, "Creating visualization...")
+    
     fig = plot_density_isosurface_slider(output, T_list)
+    
+    update_progress(100, "Complete!")
+    log("IonQ job completed successfully.")
+    
     return output, fig
   
-  return job,get_job_result
+  return job, get_job_result
 
 
 

qlbm_embedded.py

@@ -1465,6 +1465,13 @@ async def _run_simulation_async():
             last_logged_percent[0] = percent
         _qlbm_flush_state_threadsafe()  # Thread-safe flush!
     
+    # QPU progress callback with status message support
+    def _qpu_progress_callback(percent, message=None):
+        _state.qlbm_simulation_progress = percent
+        if message:
+            _state.qlbm_status_message = message
+        _qlbm_flush_state_threadsafe()
+    
     try:
         # === Qiskit Backend (IBM Qiskit Simulator) ===
         if use_qiskit:
@@ -1501,16 +1508,17 @@ async def _run_simulation_async():
         # === IBM QPU Backend ===
         elif use_ibm_qpu:
             log_to_console("Using IBM QPU backend...")
-            _state.qlbm_status_message = "Preparing IBM QPU job..."
+            _state.qlbm_status_message = "Step 1: Preparing IBM QPU job..."
+            _state.qlbm_simulation_progress = 0
             await _qlbm_flush_async()
             
             params = _map_state_to_qiskit_params()
             if params is None:
                 raise RuntimeError("Failed to map state parameters")
 
-            # Create initial state circuit
+            # Create initial state circuit (part of Step 1)
             log_to_console("Creating initial state circuit...")
-            _state.qlbm_simulation_progress = 10
+            _state.qlbm_simulation_progress = 2
             await _qlbm_flush_async()
             
             init_state_prep_circ = get_named_init_state_circuit(
@@ -1528,14 +1536,12 @@ async def _run_simulation_async():
                 mdd_kz_log2=params["mdd_kz_log2"],
             )
 
-            log_to_console("Submitting job to IBM Quantum...")
-            _state.qlbm_status_message = "Submitting job to IBM Quantum..."
-            _state.qlbm_simulation_progress = 20
+            _state.qlbm_simulation_progress = 5
+            _state.qlbm_status_message = "Step 1: Circuit generation..."
             await _qlbm_flush_async()
             
-            # Run HW simulation in executor
+            # Run HW simulation in executor with progress callback
             def _run_ibm_qpu_blocking():
-                log_to_console("Submitting and running IBM QPU job...")
                 job, get_result = run_sampling_hw_ibm(
                     n=params["n"],
                     ux=params["vx_expr"],
@@ -1546,19 +1552,18 @@ async def _run_simulation_async():
                     shots=2**14,
                     vel_resolution=min(params['grid_size'], 32),
                     output_resolution=min(2*params['grid_size'], 40),
-                    logger=log_to_console
+                    logger=log_to_console,
+                    progress_callback=_qpu_progress_callback,
                 )
-                log_to_console("Waiting for job results (this may take time)...")
+                # get_result already handles progress updates internally
                 output, plotly_fig = get_result(job)
                 return output, plotly_fig, init_state_prep_circ
             
-            _state.qlbm_status_message = "Waiting for IBM QPU results..."
-            _state.qlbm_simulation_progress = 40
-            await _qlbm_flush_async()
-            
             output, plotly_fig, init_state_prep_circ = await loop.run_in_executor(executor, _run_ibm_qpu_blocking)
             
-            _state.qlbm_simulation_progress = 80
+            # Step 3: Creating Plots is already handled in get_job_result, now add T=0 snapshot
+            _state.qlbm_simulation_progress = 92
+            _state.qlbm_status_message = "Step 3: Adding T=0 snapshot..."
             await _qlbm_flush_async()
             
             # Generate T=0 initial snapshot and prepend to output
@@ -1618,16 +1623,17 @@ async def _run_simulation_async():
         # === IonQ QPU Backend ===
         elif use_ionq_qpu:
             log_to_console("Using IonQ QPU backend...")
-            _state.qlbm_status_message = "Preparing IonQ QPU job..."
+            _state.qlbm_status_message = "Step 1: Preparing IonQ QPU job..."
+            _state.qlbm_simulation_progress = 0
             await _qlbm_flush_async()
             
             params = _map_state_to_qiskit_params()
             if params is None:
                 raise RuntimeError("Failed to map state parameters")
 
-            # Create initial state circuit
+            # Create initial state circuit (part of Step 1)
             log_to_console("Creating initial state circuit...")
-            _state.qlbm_simulation_progress = 10
+            _state.qlbm_simulation_progress = 2
             await _qlbm_flush_async()
             
             init_state_prep_circ = get_named_init_state_circuit(
@@ -1645,14 +1651,12 @@ async def _run_simulation_async():
                 mdd_kz_log2=params["mdd_kz_log2"],
             )
 
-            log_to_console("Submitting job to IonQ Quantum...")
-            _state.qlbm_status_message = "Submitting job to IonQ Quantum..."
-            _state.qlbm_simulation_progress = 20
+            _state.qlbm_simulation_progress = 5
+            _state.qlbm_status_message = "Step 1: Circuit generation..."
             await _qlbm_flush_async()
             
-            # Run IonQ HW simulation in executor
+            # Run IonQ HW simulation in executor with progress callback
             def _run_ionq_qpu_blocking():
-                log_to_console("Submitting and running IonQ QPU job...")
                 job, get_result = run_sampling_hw_ionq(
                     n=params["n"],
                     ux=params["vx_expr"],
@@ -1663,19 +1667,18 @@ async def _run_simulation_async():
                     shots=2**14,
                     vel_resolution=min(params['grid_size'], 32),
                     output_resolution=min(2*params['grid_size'], 40),
-                    logger=log_to_console
+                    logger=log_to_console,
+                    progress_callback=_qpu_progress_callback,
                 )
-                log_to_console("Waiting for IonQ job results (this may take time)...")
+                # get_result already handles progress updates internally
                 output, plotly_fig = get_result(job)
                 return output, plotly_fig, init_state_prep_circ
             
-            _state.qlbm_status_message = "Waiting for IonQ QPU results..."
-            _state.qlbm_simulation_progress = 40
-            await _qlbm_flush_async()
-            
             output, plotly_fig, init_state_prep_circ = await loop.run_in_executor(executor, _run_ionq_qpu_blocking)
             
-            _state.qlbm_simulation_progress = 80
+            # Step 3: Creating Plots is already handled in get_job_result, now add T=0 snapshot
+            _state.qlbm_simulation_progress = 92
+            _state.qlbm_status_message = "Step 3: Adding T=0 snapshot..."
             await _qlbm_flush_async()
             
             # Generate T=0 initial snapshot and prepend to output

utils/EBU_Quantum/no_body/base_functions.py

@@ -277,25 +277,52 @@ def circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yr
 
     return qc, qcdiff
 
-def get_absolute_field_values(all_circuits, shots, pm_optimization_level, simulation = "True", platform =  "IBM"):
+def get_absolute_field_values(all_circuits, shots, pm_optimization_level, simulation = "True", platform =  "IBM", progress_callback=None, print_callback=None):
+    """
+    Execute circuits on quantum backend and return field values.
+    
+    Parameters
+    ----------
+    progress_callback : callable, optional
+        Function to report progress (40-90 range for Step 2 execution)
+    print_callback : callable, optional
+        Function for logging messages
+    """
+    import time as time_module
+    
+    def _log(msg):
+        if print_callback:
+            print_callback(msg)
+    
+    def _progress(pct, message=None):
+        if progress_callback:
+            try:
+                progress_callback(pct, message)
+            except TypeError:
+                # Old-style callback without message parameter
+                try:
+                    progress_callback(pct)
+                except Exception:
+                    pass
+            except Exception:
+                pass
+    
     jobs = {}
     job_status = {key: "QUEUED" for key in jobs}
-    # while pending:
-    #     for key in pending[:]:
-    #         status = jobs[key].status()
-    #         job_status[key] = status
-    #         if status == "DONE":
-    #             pending.remove(key)
-    #     time.sleep(2)
+
+    total_circuits = len(all_circuits)
+    _log(f"Step 2: Submitting {total_circuits} circuit(s) for execution...")
+    _progress(40, f"Submitting {total_circuits} circuits...")
 
     if simulation=="True":
         backend = Aer.get_backend('qasm_simulator')
+        _log(f"Using simulator backend: {backend.name()}")
+        _progress(42, f"Backend: {backend.name()}")
+        
         pm = generate_preset_pass_manager(backend=backend, optimization_level=pm_optimization_level)
         with Batch(backend=backend, max_time="2h") as batch:
             estimator = Estimator()
-            for key, qc in all_circuits.items():
-                # Decompose high-level gates to avoid Rust panic
-                # qc = qc.decompose(["state_preparation", "initialize", "unitary", "isometry"])
+            for idx, (key, qc) in enumerate(all_circuits.items()):
                 qc = transpile(qc, basis_gates=['u', 'cx', 'rz', 'sx', 'x'])
                 pauli_label = 'Z'+'I'*(qc.num_qubits-1)
                 qc_compiled = pm.run(qc)
@@ -303,11 +330,22 @@ def get_absolute_field_values(all_circuits, shots, pm_optimization_level, simula
                 observable  = SparsePauliOp(Pauli(pauli_label)).apply_layout(layout)
                 job = estimator.run([(qc_compiled,observable)], precision=1/np.sqrt(shots))
                 jobs[key] = job
+                
+                # Progress: 42-50% for submission
+                submit_pct = 42 + ((idx + 1) / total_circuits) * 8
+                _progress(submit_pct, f"Submitted circuit {idx+1}/{total_circuits}")
+                
     elif simulation == "False" and platform == "IBM":
+        _log("Connecting to IBM Quantum service...")
+        _progress(42, "Connecting to IBM Quantum...")
+        
         service = QiskitRuntimeService(channel="ibm_cloud", 
                                token="3Upysb5eOsRuBFlML0KV0uO4Jv4Lq01MhYsJ_Nu1pszy",
                                instance="crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::")        
         backend = service.least_busy(operational=True, simulator=False)
+        _log(f"Selected IBM QPU backend: {backend.name}")
+        _progress(45, f"Backend: {backend.name}")
+        
         pm = generate_preset_pass_manager(backend=backend, optimization_level=pm_optimization_level)
         with Batch(backend=backend, max_time="2h") as batch:
             estimator = Estimator()
@@ -318,9 +356,8 @@ def get_absolute_field_values(all_circuits, shots, pm_optimization_level, simula
             estimator.options.resilience.zne_mitigation = True
             estimator.options.resilience.zne.noise_factors = (1.1, 1.3, 1.5)
             estimator.options.resilience.zne.extrapolator = ("exponential", "linear") 
-            for key, qc in all_circuits.items():
-                # Decompose high-level gates to avoid Rust panic
-                # qc = qc.decompose(["state_preparation", "initialize", "unitary", "isometry"])
+            
+            for idx, (key, qc) in enumerate(all_circuits.items()):
                 qc = transpile(qc, basis_gates=['u', 'cx', 'rz', 'sx', 'x'])
                 pauli_label = 'Z'+'I'*(qc.num_qubits-1)
                 qc_compiled = pm.run(qc)
@@ -328,30 +365,98 @@ def get_absolute_field_values(all_circuits, shots, pm_optimization_level, simula
                 observable  = SparsePauliOp(Pauli(pauli_label)).apply_layout(layout)
                 job = estimator.run([(qc_compiled,observable)], precision=1/np.sqrt(shots))
                 jobs[key] = job
+                
+                # Progress: 45-55% for submission
+                submit_pct = 45 + ((idx + 1) / total_circuits) * 10
+                _progress(submit_pct, f"Submitted circuit {idx+1}/{total_circuits}")
+                
     elif simulation == "False" and platform == "IONQ":
-        # provider = IonQProvider(token='SgUkiDq1r2bVEadyiUfvtuxQ03Qci6UW')
-        # ionq_backend = provider.get_backend("simulator")
-        # ionq_backend.set_options(noise_model="ideal")
+        _log("Connecting to IonQ service...")
+        _progress(42, "Connecting to IonQ...")
 
         provider = IonQProvider(token = 'UzmBNbWXGKjyKrGyvwiw6E3rYhPdL8AU')
         ionq_backend = provider.get_backend("qpu.forte-enterprise-1")
+        _log(f"Selected IonQ backend: {ionq_backend.name()}")
+        _progress(45, f"Backend: {ionq_backend.name()}")
 
         pm = generate_preset_pass_manager(backend=ionq_backend, optimization_level=1)
         with Batch(backend=ionq_backend, max_time="2h") as batch:
             estimator = Estimator()
-            for key, qc in all_circuits.items():
+            for idx, (key, qc) in enumerate(all_circuits.items()):
                 pauli_label = 'Z'+'I'*(qc.num_qubits-1)
-                qc_compiled = transpile(qc,basis_gates=['ry','rz','rx','h','cx'])# pm.run(qc)
+                qc_compiled = transpile(qc,basis_gates=['ry','rz','rx','h','cx'])
                 layout = qc_compiled.layout
                 observable  = SparsePauliOp(Pauli(pauli_label)).apply_layout(layout)
                 job = estimator.run([(qc_compiled,observable)], precision=1/np.sqrt(shots))
                 jobs[key] = job
+                
+                submit_pct = 45 + ((idx + 1) / total_circuits) * 10
+                _progress(submit_pct, f"Submitted circuit {idx+1}/{total_circuits}")
+    
+    # Poll for job completion with status updates (55-85%)
+    _log("Jobs submitted. Waiting for results...")
+    _progress(55, "Jobs queued, waiting for execution...")
+    
+    total_jobs = len(jobs)
+    completed_jobs = 0
+    job_keys = list(jobs.keys())
+    pending_keys = set(job_keys)
+    
+    poll_count = 0
+    max_polls = 600  # ~10 minutes with 1s interval
+    
+    while pending_keys and poll_count < max_polls:
+        for key in list(pending_keys):
+            try:
+                job = jobs[key]
+                status = job.status()
+                status_name = status.name if hasattr(status, 'name') else str(status)
+                
+                if status_name != job_status.get(key):
+                    job_status[key] = status_name
+                    _log(f"Job {key[:30]}... Status: {status_name}")
+                
+                if status_name in ('DONE', 'ERROR', 'CANCELLED'):
+                    pending_keys.discard(key)
+                    completed_jobs += 1
+                    # Progress: 55-85% based on completion
+                    completion_pct = 55 + (completed_jobs / total_jobs) * 30
+                    _progress(completion_pct, f"Completed {completed_jobs}/{total_jobs} jobs")
+                    
+            except Exception as e:
+                pass
+        
+        if pending_keys:
+            # Show indeterminate progress while waiting
+            queued_count = sum(1 for s in job_status.values() if s in ('QUEUED', 'VALIDATING', 'INITIALIZING'))
+            running_count = sum(1 for s in job_status.values() if s == 'RUNNING')
+            
+            if running_count > 0:
+                # Slowly increment while running (55-85 range)
+                run_progress = 55 + min(30, poll_count * 0.1)
+                _progress(run_progress, f"Running... ({running_count} active, {queued_count} queued)")
+            elif queued_count > 0:
+                queue_progress = 55 + min(10, poll_count * 0.05)
+                _progress(queue_progress, f"Queued... (waiting {poll_count}s)")
+            
+            time_module.sleep(1)
+            poll_count += 1
+    
+    _log("All jobs completed. Retrieving results...")
+    _progress(87, "Retrieving results...")
+    
     #########################################################################################################       
     results = {}
-    for key, job in jobs.items():
+    for idx, (key, job) in enumerate(jobs.items()):
         res = job.result()[0]
         z_exp = res.data.evs.item()   # expectation value
         results[key] = np.sqrt((1 - z_exp) / 2)
+        
+        # Progress: 87-90% for result retrieval
+        result_pct = 87 + ((idx + 1) / total_jobs) * 3
+        _progress(result_pct, f"Retrieved result {idx+1}/{total_jobs}")
+    
+    _progress(90, "All results retrieved")
     #########################################################################################
     return results
 
@@ -590,7 +695,7 @@ def get_field_values(field, x, y, T, snapshot_time, nx, impulse_pos, shots, pm_o
         except Exception:
             pass
 
-    results = get_absolute_field_values(all_circuits, shots, pm_optimization_level, simulation, platform)
+    results = get_absolute_field_values(all_circuits, shots, pm_optimization_level, simulation, platform, progress_callback=progress_callback, print_callback=print_callback)
     
     # --- Step 3: Result Processing (90-100%) ---
     _log("Step 3: Result Processing")