QLBM : IBM QPU version integrated

qlbm/qlbm_sample_app.py

@@ -423,7 +423,10 @@ from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 import pprint
 # import mthree
-# from ...Quantum_LBM_AdvecDiff.qlbm.visualize_counts import load_samples, estimate_density, plot_density_isosurface
+try:
+    from qlbm.visualize_counts import load_samples, estimate_density, plot_density_isosurface, plot_density_isosurface_slider
+except ImportError:
+    from visualize_counts import load_samples, estimate_density, plot_density_isosurface, plot_density_isosurface_slider
 
 
 def run_sampling_hw_ibm(
@@ -436,6 +439,7 @@ def run_sampling_hw_ibm(
     shots=2**19,
     vel_resolution=32,
     output_resolution=40,
+    logger=None,
 ):
   """
   Run QLBM simulation on IBM quantum hardware.
@@ -456,15 +460,23 @@ def run_sampling_hw_ibm(
       Resolution for velocity field discretization
   output_resolution : int
       Grid resolution for density estimation output
+  logger : callable, optional
+      Function to log messages (e.g. print to console)
   
   Returns
   -------
   job : IBMJob
       The submitted job object
   get_job_result : callable
-      Callback function to retrieve and process results
+      Callback function to retrieve and process results. Returns (output, fig).
   """
 
+  def log(msg):
+      if logger:
+          logger(str(msg))
+      else:
+          print(msg)
+
   if type(ux)==str:
     ux,uy,uz=str_to_lambda(ux,uy,uz)
 
@@ -479,10 +491,10 @@ def run_sampling_hw_ibm(
 
   for qc in qc_list:
     pm = generate_preset_pass_manager(backend=backend, optimization_level=pm_optimization_level)
-    print("Generating ISA circuit via PassManager (preserves measurements/conditionals).")
+    log("Generating ISA circuit via PassManager (preserves measurements/conditionals).")
     qc_compiled = pm.run(qc)   # this is the recommended replacement for transpile(..., backend=backend)
-    print("Compiled circuit qubits/clbits:", qc_compiled.num_qubits, qc_compiled.num_clbits)
-    print("Depth: ", qc_compiled.depth())
+    log(f"Compiled circuit qubits/clbits: {qc_compiled.num_qubits} {qc_compiled.num_clbits}")
+    log(f"Depth: {qc_compiled.depth()}")
     qc_compiled_list+=[qc_compiled]
 
   # Create Sampler primitive bound to the backend
@@ -490,43 +502,44 @@ def run_sampling_hw_ibm(
 
   # Submit job: pass a list of PUBs (we send one PUB [qc_compiled])
   job = sampler.run(qc_compiled_list, shots=shots)
-  print("Job submitted; waiting for result...")
+  log("Job submitted; waiting for result...")
 
   def get_job_result(j):
     result = j.result()   # PrimitiveResult (a container of PubResults)
-    print(result)
+    log(str(result))
 
     output=[]
 
     for T_total,pub in zip(T_list,result):
 
       # We'll inspect the first PUB result
-      print("PUB metadata:", pub.metadata if hasattr(pub, "metadata") else "<no metadata>")
+      log(f"PUB metadata: {pub.metadata if hasattr(pub, 'metadata') else '<no metadata>'}")
 
       # 1) Try to obtain counts via the recommended API
       try:
           counts = pub.data.meas.get_counts()
-          print("\nCounts (pub.data.meas.get_counts()) sample:")
-          pprint.pprint({k: counts[k] for k in list(counts)[:10]})
+          log("\nCounts (pub.data.meas.get_counts()) sample:")
+          log(str({k: counts[k] for k in list(counts)[:10]}))
       except Exception as e:
-          print("Couldn't call pub.data.meas.get_counts():", e)
+          log(f"Couldn't call pub.data.meas.get_counts(): {e}")
           counts = None
 
       # 2) 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_counts = joined.get_counts()
-          print("\nJoined counts (pub.join_data().get_counts()) sample:")
-          pprint.pprint({k: joined_counts[k] for k in list(joined_counts)[:10]})
+          log("\nJoined counts (pub.join_data().get_counts()) sample:")
+          log(str({k: joined_counts[k] for k in list(joined_counts)[:10]}))
       except Exception as e:
-          print("join_data()/joined.get_counts() not available or failed:", e)
+          log(f"join_data()/joined.get_counts() not available or failed: {e}")
           joined_counts = None
 
 
       pts, counts = load_samples(joined_counts,T_total)
       output+=[estimate_density(pts, counts, bandwidth=0.05, grid_size=output_resolution)]
 
-    return output
+    fig = plot_density_isosurface_slider(output, T_list)
+    return output, fig
   
   return job,get_job_result
 

qlbm/visualize_counts.py

@@ -0,0 +1,192 @@
+import numpy as np
+from sklearn.neighbors import KernelDensity
+import plotly.graph_objects as go
+
+def bitstring_to_xyz(bs):
+    """
+    Interpret the bitstring `bs` by dividing it into three equal thirds,
+    and converting each third to an integer or normalized float.
+    Returns (x, y, z).
+    """
+    n = len(bs)
+    assert n % 3 == 0, "Bitstring length must be divisible by 3"
+    t = n // 3
+    bx = bs[0:t]
+    by = bs[t:2*t]
+    bz = bs[2*t:3*t]
+    # convert each to integer (or normalized in [0,1])
+    ix = int(bx, 2)
+    iy = int(by, 2)
+    iz = int(bz, 2)
+    # Optionally normalize by 2^t
+    maxv = (1 << t)
+    return ix / maxv, iy / maxv, iz / maxv
+
+def load_samples(d,T_total):
+  pts = []
+  counts = []
+  for bs, cnt in d.items():
+    if bs[:6*T_total] == "0" * 6*T_total:
+      if cnt<0:
+         continue
+      x, y, z = bitstring_to_xyz(bs[6*T_total:])
+      pts.append([x, y, z])
+      counts.append(cnt)
+  pts = np.array(pts)
+  counts = np.array(counts)
+  print("Number of valid counts:", np.sum(counts))
+  print("Number of valid bitstrings:", len(counts))
+#   counts=counts*len(counts)*10/np.sum(counts)
+#   print(counts)
+  return pts, counts
+
+def estimate_density(pts, counts, bandwidth=0.05, grid_size=64):
+    """
+    Fit KDE weighted by counts, and evaluate on a grid.
+    Returns (grid_x, grid_y, grid_z, grid_density) where
+    grid_x, etc. are 3D mesh arrays, and grid_density has same shape.
+    """
+    # Expand points by weights: we can replicate points (if counts small),
+    # or directly use weights in log-likelihood calculation.
+    # sklearn’s KernelDensity doesn’t support sample weights in .fit,
+    # but you can approximate by replication or by customizing the KDE.
+    # Here, for simplicity, replicate (careful of explosion):
+    pts_rep = np.repeat(pts, counts.astype(int), axis=0)
+    kde = KernelDensity(bandwidth=bandwidth, kernel='gaussian')
+    kde.fit(pts_rep)
+
+    # create a 3D grid over the bounding box
+    # mins = pts.min(axis=0)
+    # maxs = pts.max(axis=0)
+    mins=[0,0,0]
+    maxs=[1,1,1]
+    xs = np.linspace(mins[0], maxs[0], grid_size)
+    ys = np.linspace(mins[1], maxs[1], grid_size)
+    zs = np.linspace(mins[2], maxs[2], grid_size)
+    xx, yy, zz = np.meshgrid(xs, ys, zs, indexing='ij')
+    grid_coords = np.vstack([xx.ravel(), yy.ravel(), zz.ravel()]).T
+
+    logdens = kde.score_samples(grid_coords)  # log density
+    dens = np.exp(logdens)
+    dens = dens.reshape(xx.shape)
+
+    print("Mins:", mins)
+    print("Maxs:", maxs)
+    print("dens:", dens)
+
+    return xx, yy, zz, dens
+
+def plot_density_isosurface(xx, yy, zz, dens, level=None):
+    """
+    Plot an isosurface of density using Plotly.
+    If level is None, choose a percentile.
+    """
+    if level is None:
+        level = np.percentile(dens, 90)  # for example, top 10% density
+
+    fig = go.Figure(
+        data=go.Isosurface(
+            x=xx.ravel(),
+            y=yy.ravel(),
+            z=zz.ravel(),
+            value=dens.ravel(),
+            isomin=level,
+            isomax= dens.max(),
+            # surface_count=1,  # one isosurface
+            opacity=0.4, # needs to be small to see through all surfaces
+            surface_count=5, # needs to be a large number for good volume rendering,    
+            # caps=dict(x_show=False, y_show=False, z_show=False)
+            caps=dict(x_show=False, y_show=False, z_show=False),
+            showscale=True,
+        )
+    )
+    fig.update_layout(
+        scene=dict(
+            xaxis_title="x",
+            yaxis_title="y",
+            zaxis_title="z",
+        ),
+        title="3D Density Isosurface"
+    )
+    fig.show(renderer="browser")
+
+def plot_density_isosurface_slider(outputs, T_list=None):
+    """
+    Plot an isosurface of density using Plotly with a slider for timesteps.
+    outputs: list of (xx, yy, zz, dens) tuples.
+    T_list: list of timestep values corresponding to outputs.
+    """
+    if not outputs:
+        print("No output to plot.")
+        return
+
+    # If T_list is not provided, generate indices
+    if T_list is None:
+        T_list = list(range(len(outputs)))
+
+    # Compute global min/max for consistent color scaling
+    # dens is the 4th element (index 3) in the tuple (xx, yy, zz, dens)
+    all_dens = [out[3] for out in outputs]
+    global_min = min(np.min(d) for d in all_dens)
+    global_max = max(np.max(d) for d in all_dens)
+    
+    fig = go.Figure()
+
+    # Add a trace for each timestep
+    for i, (xx, yy, zz, dens) in enumerate(outputs):
+        visible = (i == 0)  # Only the first trace is visible initially
+        
+        fig.add_trace(go.Isosurface(
+            x=xx.ravel(),
+            y=yy.ravel(),
+            z=zz.ravel(),
+            value=dens.ravel(),
+            isomin=global_min,
+            isomax=global_max,
+            opacity=0.4,
+            surface_count=5,
+            caps=dict(x_show=False, y_show=False, z_show=False),
+            colorscale='Blues',
+            colorbar=dict(title="Density"),
+            visible=visible,
+            name=f"T={T_list[i]}"
+        ))
+
+    # Create slider steps
+    steps = []
+    for i, T in enumerate(T_list):
+        step = dict(
+            method="update",
+            args=[{"visible": [False] * len(outputs)},
+                  {"title": f"QLBM Simulation - Timestep T={T}"}],
+            label=str(T)
+        )
+        step["args"][0]["visible"][i] = True  # Toggle i-th trace to True
+        steps.append(step)
+
+    sliders = [dict(
+        active=0,
+        currentvalue={"prefix": "Timestep: "},
+        pad={"t": 50},
+        steps=steps
+    )]
+
+    fig.update_layout(
+        title=f"QLBM Simulation - Timestep T={T_list[0]}",
+        scene=dict(
+            xaxis_title="X",
+            yaxis_title="Y",
+            zaxis_title="Z",
+            aspectmode='cube',
+        ),
+        sliders=sliders
+    )
+    
+    # fig.show(renderer="browser")
+    return fig
+
+# if __name__ == '__main__':
+#     pts, counts = load_samples('counts_7_3.json')
+#     # pts, counts = load_samples('quasis_8_3.txt')
+#     xx, yy, zz, dens = estimate_density(pts, counts, bandwidth=0.05, grid_size=40)
+#     plot_density_isosurface(xx, yy, zz, dens)

qlbm_embedded.py

@@ -29,6 +29,7 @@ _QISKIT_IMPORT_ERROR = None
 try:
     from qlbm.qlbm_sample_app import (
         run_sampling_sim,
+        run_sampling_hw_ibm,
         get_named_init_state_circuit,
         str_to_lambda,
         _create_slider_figure,
@@ -995,6 +996,11 @@ def run_simulation():
         _state.qlbm_selected_simulator == "IBM Qiskit simulator" and
         _QISKIT_BACKEND_AVAILABLE
     )
+    use_ibm_qpu = (
+        _state.qlbm_backend_type == "QPU" and 
+        _state.qlbm_selected_qpu == "IBM QPU" and
+        _QISKIT_BACKEND_AVAILABLE
+    )
     
     # Log initial configuration
     backend_info = f"{_state.qlbm_backend_type}"
@@ -1049,6 +1055,62 @@ def run_simulation():
             log_to_console("Qiskit simulation completed successfully.")
             _state.qlbm_status_message = "Simulation completed successfully."
             _state.qlbm_status_type = "success"
+
+        # === IBM QPU Backend ===
+        elif use_ibm_qpu:
+            log_to_console("Using IBM QPU backend...")
+            
+            params = _map_state_to_qiskit_params()
+            if params is None:
+                raise RuntimeError("Failed to map state parameters")
+
+            # Create initial state circuit
+            log_to_console("Creating initial state circuit...")
+            init_state_prep_circ = get_named_init_state_circuit(
+                n=params["n"],
+                init_state_name=params["init_state_name"],
+                sine_k_x=params["sine_k_x"],
+                sine_k_y=params["sine_k_y"],
+                sine_k_z=params["sine_k_z"],
+                gauss_cx=params["gauss_cx"],
+                gauss_cy=params["gauss_cy"],
+                gauss_cz=params["gauss_cz"],
+                gauss_sigma=params["gauss_sigma"],
+            )
+
+            log_to_console("Submitting job to IBM Quantum...")
+            
+            # Run HW simulation
+            job, get_result = run_sampling_hw_ibm(
+                n=params["n"],
+                ux=params["vx_expr"],
+                uy=params["vy_expr"],
+                uz=params["vz_expr"],
+                init_state_prep_circ=init_state_prep_circ,
+                T_list=params["T_list"],
+                shots=2**14, # Reduced shots for responsiveness/quota
+                vel_resolution=min(params['grid_size'], 32),
+                output_resolution=40,
+                logger=log_to_console
+            )
+            
+            log_to_console("Waiting for job results (this may take time)...")
+            output, plotly_fig = get_result(job)
+            
+            # Update UI
+            if hasattr(_ctrl, "qlbm_qiskit_result_update"):
+                _ctrl.qlbm_qiskit_result_update(plotly_fig)
+            
+            _state.qlbm_max_time_step = len(output) - 1
+            _state.qlbm_time_val = 0
+            _state.qlbm_time_slider_labels = [f"T={t}" for t in params["T_list"]]
+            _state.qlbm_simulation_has_run = True
+            _state.qlbm_qiskit_mode = True
+            
+            _progress_callback(100)
+            log_to_console("IBM QPU simulation completed successfully.")
+            _state.qlbm_status_message = "Simulation completed successfully."
+            _state.qlbm_status_type = "success"
         
         # === CUDA-Q Backend ===
         elif _state.qlbm_backend_type == "Simulator" and _state.qlbm_selected_simulator == "CUDA-Q simulator":