the plots should have distinct colors

em_trame.py

@@ -4,6 +4,8 @@ import pyvista as pv
 import threading
 import base64
 from collections import defaultdict
+import tempfile
+from pathlib import Path
 
 from trame.app import get_server
 from trame_vuetify.ui.vuetify3 import SinglePageLayout
@@ -367,7 +369,7 @@ def _refresh_qpu_plot_figures():
         state.qpu_ts_other_ready = False
         state.qpu_other_plot_style = "display: none; width: 900px; height: 660px; margin: 0 auto;"
 
-def _build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt: float, impulse_pos, progress_callback=None):
+def _build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt: float, impulse_pos, progress_callback=None, print_callback=None):
     times = qutils.create_time_frames(T, snapshot_dt)
     fig = go.Figure()
     # Gather all validated positions across configs (after expanding 'All') to compute color normalization
@@ -421,11 +423,16 @@ def _build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt:
 
         # Fetch time series from QPU for this field and the validated positions
         try:
-            series_map_field = qutils.run_qpu(field_type, valid_positions, None, float(T), float(snapshot_dt), int(nx), None, impulse_pos, progress_callback=_sub_progress)
+            series_map_field = qutils.run_qpu(field_type, valid_positions, None, float(T), float(snapshot_dt), int(nx), None, impulse_pos, progress_callback=_sub_progress, print_callback=print_callback)
         except Exception as e:
-            print(f"QPU error for {field_type} positions {valid_positions}: {e}")
+            msg = f"QPU error for {field_type} positions {valid_positions}: {e}"
+            if print_callback:
+                print_callback(msg)
+            else:
+                print(msg)
             continue
         cmap = _cmap_for_field(field_type)
+        num_pts = len(valid_positions)
         for i, (px, py) in enumerate(valid_positions):
             ys = (series_map_field or {}).get((px, py), [])
             if not ys or len(ys) != len(times):
@@ -435,9 +442,16 @@ def _build_qpu_timeseries_plotly_multi(configs, nx: int, T: float, snapshot_dt:
                 max_abs = max(max_abs, max((abs(float(v)) for v in ys)))
             except Exception:
                 pass
-            # Color keyed by normalized (px+py)
-            s = max(0.0, min(1.0, (px + py) / float(max_sum)))
-            rgba = cmap(s)
+            
+            # Color keyed by index to ensure distinctness
+            if num_pts > 1:
+                # Distribute from 0.3 (light) to 0.9 (dark)
+                s_index = i / (num_pts - 1)
+                s_light = 0.3 + 0.6 * s_index
+            else:
+                s_light = 0.6  # Medium intensity for single point
+            
+            rgba = cmap(s_light)
             color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
             label = _normalized_position_label(px, py, gw, gh)
             key = (str(field_type), int(px), int(py))
@@ -531,7 +545,9 @@ def _rebuild_qpu_fig_filtered(filter_value: str, position_filter: str = "All pos
         markers = ["circle", "square", "diamond", "triangle-up", "x"]
         max_abs = 0.0
         label_map = qpu_ts_cache.get("key_to_label") or {}
-        for i, k in enumerate(sorted(keys, key=lambda x: (str(x[0]), x[1], x[2]))):
+        sorted_keys = sorted(keys, key=lambda x: (str(x[0]), x[1], x[2]))
+        num_keys = len(sorted_keys)
+        for i, k in enumerate(sorted_keys):
             field_name, px, py = k
             ys = series_map.get(k) or []
             if not ys or len(ys) != len(times):
@@ -541,8 +557,15 @@ def _rebuild_qpu_fig_filtered(filter_value: str, position_filter: str = "All pos
             except Exception:
                 pass
             cmap = _cmap_for_field(field_name)
-            s = max(0.0, min(1.0, (px + py) / float(max_sum)))
-            rgba = cmap(s)
+            
+            # Color keyed by index to ensure distinctness
+            if num_keys > 1:
+                s_index = i / (num_keys - 1)
+                s_light = 0.3 + 0.6 * s_index
+            else:
+                s_light = 0.6
+            
+            rgba = cmap(s_light)
             color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
             label = label_map.get((str(field_name), int(px), int(py))) or _format_grid_label(px, py, field_name)
             fig.add_trace(go.Scatter(
@@ -636,14 +659,14 @@ def export_qpu_timeseries_csv():
         field = qpu_ts_cache.get("field") or "Ez"
         if not times or not series_map:
             raise ValueError("No QPU time series to export.")
-        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
-        os.makedirs(dl_dir, exist_ok=True)
+        
         nx_val = int(state.nx or 0)
         from datetime import datetime as _dt
-        path = os.path.join(dl_dir, f"qpu_timeseries_{field}_nx{nx_val}_{_dt.now().strftime('%Y%m%d_%H%M%S')}.csv")
+        filename = f"qpu_timeseries_{field}_nx{nx_val}_{_dt.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        
         import csv
-        with open(path, "w", newline="") as f:
-            writer = csv.writer(f)
+        with tempfile.NamedTemporaryFile(mode='w', newline='', suffix=".csv", delete=False) as tmp:
+            writer = csv.writer(tmp)
             # Detect key layout: (px,py) legacy or (field,px,py)
             keys = list(series_map.keys())
             if keys and len(keys[0]) == 3:
@@ -660,7 +683,13 @@ def export_qpu_timeseries_csv():
                 for i, t in enumerate(times):
                     row = [t] + [ (series_map.get((px,py)) or [None])[i] if i < len(series_map.get((px,py)) or []) else None for (px,py) in pts ]
                     writer.writerow(row)
-        state.export_status_message = f"Exported QPU CSV to {path}"
+            temp_path = tmp.name
+            
+        content = Path(temp_path).read_bytes()
+        server.controller.download_file(content, filename)
+        Path(temp_path).unlink()
+
+        state.export_status_message = f"Exported QPU CSV to {filename}"
     except Exception as e:
         state.export_status_message = f"QPU CSV export failed: {e}"
     finally:
@@ -674,12 +703,20 @@ def export_qpu_timeseries_png():
         field = qpu_ts_cache.get("field") or "Ez"
         if fig is None:
             raise ValueError("No QPU time series to export.")
-        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
-        os.makedirs(dl_dir, exist_ok=True)
+        
         nx_val = int(state.nx or 0)
-        path = os.path.join(dl_dir, f"qpu_timeseries_{field}_nx{nx_val}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png")
-        fig.write_image(path, scale=2, width=900, height=660)
-        state.export_status_message = f"Exported QPU PNG to {path}"
+        filename = f"qpu_timeseries_{field}_nx{nx_val}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+        
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+            temp_path = tmp.name
+        
+        fig.write_image(temp_path, scale=2, width=900, height=660)
+        
+        content = Path(temp_path).read_bytes()
+        server.controller.download_file(content, filename)
+        Path(temp_path).unlink()
+        
+        state.export_status_message = f"Exported QPU PNG to {filename}"
     except Exception as e:
         msg = str(e)
         if "kaleido" in msg.lower():
@@ -697,12 +734,20 @@ def export_qpu_timeseries_html():
         field = qpu_ts_cache.get("field") or "Ez"
         if fig is None:
             raise ValueError("No QPU time series to export.")
-        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
-        os.makedirs(dl_dir, exist_ok=True)
+        
         nx_val = int(state.nx or 0)
-        path = os.path.join(dl_dir, f"qpu_timeseries_{field}_nx{nx_val}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html")
-        pio.write_html(fig, file=path, include_plotlyjs="cdn", full_html=True)
-        state.export_status_message = f"Exported QPU HTML to {path}"
+        filename = f"qpu_timeseries_{field}_nx{nx_val}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
+        
+        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as tmp:
+            temp_path = tmp.name
+            
+        pio.write_html(fig, file=temp_path, include_plotlyjs="cdn", full_html=True)
+        
+        content = Path(temp_path).read_bytes()
+        server.controller.download_file(content, filename)
+        Path(temp_path).unlink()
+        
+        state.export_status_message = f"Exported QPU HTML to {filename}"
     except Exception as e:
         state.export_status_message = f"QPU HTML export failed: {e}"
     finally:
@@ -836,7 +881,7 @@ def run_simulation_only():
             state.status_message = "Building QPU time series..."
             state.simulation_progress = 60
             # Build and render Plotly chart (multi-config)
-            fig = _build_qpu_timeseries_plotly_multi(configs, nx, T, snapshot_dt, impulse_pos, progress_callback=_progress_callback)
+            fig = _build_qpu_timeseries_plotly_multi(configs, nx, T, snapshot_dt, impulse_pos, progress_callback=_progress_callback, print_callback=log_to_console)
             qpu_ts_cache["fig"] = fig
             try:
                 ctrl.qpu_ts_update(fig)
@@ -863,7 +908,7 @@ def run_simulation_only():
                 state.error_message = "No QPU time series generated. Check Δt, T, nx, and monitor points."
                 state.status_message = "Warning: No QPU time series generated."
                 state.status_type = "warning"
-            print("QPU complete.")
+            log_to_console("QPU complete.")
         except Exception as e:
             state.error_message = f"QPU run failed: {e}"
             state.status_message = f"QPU Error: {e}"
@@ -871,14 +916,14 @@ def run_simulation_only():
             state.show_progress = False
             state.run_button_text = "Run Simulation"
             state.qpu_ts_ready = False
-            print(f"QPU error: {e}")
+            log_to_console(f"QPU error: {e}")
         finally:
             state.is_running = False
             state.stop_button_disabled = True
             ctrl.view_update()
         return
 
-    print("Running simulation...")
+    log_to_console("Running simulation...")
     state.status_message = "Running simulation... This may take a while."
     state.simulation_progress = 30
     # Pass user-defined snapshot Δt; keep solver dt=0.1 inside run_sim
@@ -887,8 +932,7 @@ def run_simulation_only():
         return stop_simulation
     
     state.simulation_progress = 50
-    simulation_data, snapshot_times = run_sim(nx, na, R, initial_state, T, snapshot_dt=snapshot_dt, stop_check=_stop_check, progress_callback=_progress_callback)
-    print("Simulation complete.")
+    simulation_data, snapshot_times = run_sim(nx, na, R, initial_state, T, snapshot_dt=snapshot_dt, stop_check=_stop_check, progress_callback=_progress_callback, print_callback=log_to_console)
     log_to_console("Simulation complete.")
     
     state.simulation_progress = 80
@@ -1438,7 +1482,8 @@ def update_geometry_preview():
     denom = max(nx - 1, 1)
     x, y = np.arange(nx) / denom, np.arange(nx) / denom
     X, Y = np.meshgrid(x, y)
-    Z = np.zeros_like(X, dtype=float)
+    Z = np.zeros_like(X,
+ dtype=float)
     points = np.c_[X.ravel(), Y.ravel(), Z.ravel()]
     poly = pv.PolyData(points)
     mesh = poly.delaunay_2d()
@@ -1972,20 +2017,25 @@ def export_vtk():
         state.show_export_status = True
         return
     try:
-        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
-        os.makedirs(dl_dir, exist_ok=True)
         field = state.surface_field or "Ez"
         nx = int(state.nx)
         suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
-        path = os.path.join(dl_dir, f"surface_{field}_nx{nx}_{suffix}.vtp")
-        current_mesh.save(path)
-        state.export_status_message = f"Exported VTK to {path}"
+        filename = f"surface_{field}_nx{nx}_{suffix}.vtp"
+        
+        # Write to a temporary file first
+        with tempfile.NamedTemporaryFile(suffix=".vtp", delete=False) as tmp:
+            current_mesh.save(tmp.name)
+            content = Path(tmp.name).read_bytes()
+            server.controller.download_file(content, filename)
+            Path(tmp.name).unlink() # Clean up
+
+        state.export_status_message = f"Exported VTK to {filename}"
     except Exception as e:
         state.export_status_message = f"Export failed: {e}"
     state.show_export_status = True
 
 def export_vtk_all_frames():
-    """Export a .vtp file for each time frame of the selected component into a timestamped folder in Downloads."""
+    """Export a .vtp file for each time frame of the selected component into a zip file."""
     global data_frames, X_grids, z_scale, snapshot_times
     try:
         if not state.simulation_has_run:
@@ -1997,22 +2047,37 @@ def export_vtk_all_frames():
         if snapshot_times is None:
             raise ValueError("Snapshot times are unavailable.")
 
-        dl_dir = os.path.expanduser("~/Downloads")
-        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
         nx = int(state.nx)
-        out_dir = os.path.join(dl_dir, f"vtk_sequence_{field}_nx{nx}_{suffix}")
-        os.makedirs(out_dir, exist_ok=True)
-
-        times = np.asarray(snapshot_times)
-        for i, (z_data, t) in enumerate(zip(frames, times)):
-            points = np.c_[X_grids[field].ravel(), Y_grids[field].ravel(), z_data.ravel() * z_scale]
-            poly = pv.PolyData(points)
-            mesh = poly.delaunay_2d()
-            mesh["scalars"] = z_data.ravel()
-            fname = f"{field}_frame_{i:04d}_t{t:.3f}s.vtp"
-            mesh.save(os.path.join(out_dir, fname))
-
-        state.export_status_message = f"Exported {len(frames)} frames to {out_dir}"
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        zip_filename = f"vtk_sequence_{field}_nx{nx}_{suffix}.zip"
+        
+        import zipfile
+        
+        with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp_zip:
+            temp_zip_path = tmp_zip.name
+            
+        with zipfile.ZipFile(temp_zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+            times = np.asarray(snapshot_times)
+            for i, (z_data, t) in enumerate(zip(frames, times)):
+                points = np.c_[X_grids[field].ravel(), Y_grids[field].ravel(), z_data.ravel() * z_scale]
+                poly = pv.PolyData(points)
+                mesh = poly.delaunay_2d()
+                mesh["scalars"] = z_data.ravel()
+                
+                fname = f"{field}_frame_{i:04d}_t{t:.3f}s.vtp"
+                
+                with tempfile.NamedTemporaryFile(suffix=".vtp", delete=False) as tmp_vtp:
+                    tmp_vtp_path = tmp_vtp.name
+                
+                mesh.save(tmp_vtp_path)
+                zf.write(tmp_vtp_path, arcname=fname)
+                Path(tmp_vtp_path).unlink()
+
+        content = Path(temp_zip_path).read_bytes()
+        server.controller.download_file(content, zip_filename)
+        Path(temp_zip_path).unlink()
+
+        state.export_status_message = f"Exported {len(frames)} frames to {zip_filename}"
     except Exception as e:
         state.export_status_message = f"Export failed: {e}"
     finally:
@@ -2031,12 +2096,13 @@ def export_mp4():
         if len(frames) < 2:
             raise ValueError("Only one frame available; increase T or simulation steps.")
 
-        # Output path
-        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
-        os.makedirs(dl_dir, exist_ok=True)
         nx = int(state.nx)
         suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
-        path = os.path.join(dl_dir, f"surface_anim_{field}_nx{nx}_{suffix}.mp4")
+        filename = f"surface_anim_{field}_nx{nx}_{suffix}.mp4"
+
+        # Create a temporary file for the MP4
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
+            temp_path = tmp.name
 
         # Build with a dedicated off-screen plotter at a macro-block friendly size
         movie_plotter = pv.Plotter(off_screen=True, window_size=(1280, 720))
@@ -2069,7 +2135,7 @@ def export_mp4():
         except Exception:
             movie_plotter.view_isometric()
 
-        movie_plotter.open_movie(path, framerate=20)
+        movie_plotter.open_movie(temp_path, framerate=20)
         n_frames = len(frames)
         for z_data in frames:
             if mesh.n_points != z_data.size:
@@ -2096,7 +2162,12 @@ def export_mp4():
             movie_plotter.write_frame()
         movie_plotter.close()
 
-        state.export_status_message = f"Exported MP4 to {path}"
+        # Read the file content and trigger download
+        content = Path(temp_path).read_bytes()
+        server.controller.download_file(content, filename)
+        Path(temp_path).unlink() # Clean up
+
+        state.export_status_message = f"Exported MP4 to {filename}"
     except Exception as e:
         state.export_status_message = f"Export failed: {e}"
     finally:
@@ -2319,8 +2390,10 @@ def _rebuild_qpu_fig_others(selected_field: str, position_filter: str = "All pos
         dashes = ["solid", "dash", "dot", "dashdot"]
         markers = ["circle", "square", "diamond", "triangle-up", "x"]
         max_abs = 0.0
-        for i, k in enumerate(sorted(keys, key=lambda x: (x[1], x[2]))):
-            _, px, py = k
+        sorted_keys = sorted(keys, key=lambda x: (x[1], x[2]))
+        num_keys = len(sorted_keys)
+        for i, k in enumerate(sorted_keys):
+            field_name, px, py = k
             ys = series_map.get(k) or []
             if not ys or len(ys) != len(times):
                 continue
@@ -2328,13 +2401,20 @@ def _rebuild_qpu_fig_others(selected_field: str, position_filter: str = "All pos
                 max_abs = max(max_abs, max((abs(float(v)) for v in ys)))
             except Exception:
                 pass
-            s = max(0.0, min(1.0, (px + py) / float(max_sum)))
-            rgba = cmap(s)
+            
+            # Color keyed by index to ensure distinctness
+            if num_keys > 1:
+                s_index = i / (num_keys - 1)
+                s_light = 0.3 + 0.6 * s_index
+            else:
+                s_light = 0.6
+            
+            rgba = cmap(s_light)
             color_hex = f"#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}"
             fig.add_trace(go.Scatter(
                 x=times, y=ys, mode='lines+markers', name=f"({px}, {py})",
-                line=dict(color=color_hex, width=2.5, dash=dash_styles[i % len(dash_styles)]),
-                marker=dict(size=7, symbol=marker_symbols[i % len(marker_symbols)], color=color_hex),
+                line=dict(color=color_hex, width=2.5, dash=dashes[i % len(dashes)]),
+                marker=dict(size=7, symbol=markers[i % len(markers)], color=color_hex),
                 hovertemplate=f"{sel} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>({px}, {py})</extra>",
             ))
         fig.update_layout(title=f"IBM QPU Time Series (Other components: {sel})", height=660, width=900, margin=dict(l=50, r=30, t=50, b=50), hovermode="x unified", legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, title_text=""))
@@ -2814,7 +2894,7 @@ with SinglePageLayout(server) as layout:
 
                     # Console Window
                     with vuetify3.VCard(classes="mt-2", style="font-size: 0.8rem;"):
-                        with vuetify3.VCardTitle("Console Output", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+                        with vuetify3.VCardTitle("Status", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
                             pass
                         with vuetify3.VCardText(classes="py-1 px-2", style="height: 150px; overflow-y: auto; background-color: #f5f5f5; font-family: monospace;"):
                             vuetify3.VTextarea(

requirements.txt

@@ -31,3 +31,8 @@ trame_plotly
 Pillow==10.4.0
 packaging==25.0
 python-dateutil==2.9.0.post0
+
+# Export utilities
+imageio
+imageio-ffmpeg
+kaleido

utils/delta_impulse_generator.py

@@ -245,7 +245,7 @@ def V2(nx, dt):
     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):
+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],
@@ -254,6 +254,12 @@ def run_sim(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, prog
     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:
@@ -310,9 +316,11 @@ def run_sim(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, prog
     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():
-            print(f"Simulation interrupted at step {i}/{steps}")
+            _log(f"Simulation interrupted at step {i}/{steps}")
             break
         # One solver step
         qc.append(QFTGate(na), ancilla)
@@ -342,6 +350,8 @@ def run_sim(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, prog
             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)
@@ -402,13 +412,19 @@ def create_time_frames(total_time, snapshot_interval):
 
 
 
-def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos):
+def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos, progress_callback=None, print_callback=None):
     """
     Compute time-series field values. Supports single-point and multi-point modes.
 
     - 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
@@ -434,6 +450,9 @@ def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos):
     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:
@@ -441,7 +460,7 @@ def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos):
     else:
         series_single = []
 
-    for time in time_frames:
+    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')
@@ -464,5 +483,10 @@ def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos):
                 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("QPU simulation completed.")
 
     return series_by_point if multi else series_single