QLBM : IBM QPU version integrated

qlbm/qlbm_sample_app.py

@@ -390,13 +390,16 @@ def get_named_init_state_circuit(
     # Configurable Gaussian distribution
     # f(x,y,z) = exp(-((x-cx)^2 + (y-cy)^2 + (z-cz)^2) / (2*sigma^2))
     
-    # Default centers to 0.5 (middle of domain)
+    # Default centers to 0.5 (middle of domain) - matches original mu=0.5
     cx = float(gauss_cx) if gauss_cx is not None else 0.5
     cy = float(gauss_cy) if gauss_cy is not None else 0.5
     cz = float(gauss_cz) if gauss_cz is not None else 0.5
     
-    # Default sigma to 0.2 (similar to original sig=1 with mu=0.5 behavior)
-    sigma = float(gauss_sigma) if gauss_sigma is not None else 0.2
+    # Default sigma to 1.0 to match original sig=1 behavior
+    # Original formula: exp(-((x - mu) / sig)^2 / 2) with sig=1
+    # Our formula: exp(-((x - cx)^2) / (2 * sigma^2))
+    # For equivalence: sigma = 1.0 (they are the same formula)
+    sigma = float(gauss_sigma) if gauss_sigma is not None else 1.0
     
     coords = np.arange(N) / N  # Normalized [0, 1)
     
@@ -486,6 +489,10 @@ def run_sampling_hw_ibm(
   if type(ux)==str:
     ux,uy,uz=str_to_lambda(ux,uy,uz)
 
+  # 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)
+
   qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution)
 
   pm_optimization_level = 3
@@ -541,7 +548,7 @@ def run_sampling_hw_ibm(
           joined_counts = None
 
 
-      pts, counts = load_samples(joined_counts,T_total)
+      pts, counts = load_samples(joined_counts, T_total, logger=log)
       output+=[estimate_density(pts, counts, bandwidth=0.05, grid_size=output_resolution)]
 
     fig = plot_density_isosurface_slider(output, T_list)
@@ -589,6 +596,10 @@ def run_sampling_sim(
   if type(ux)==str:
     ux,uy,uz=str_to_lambda(ux,uy,uz)
 
+  # 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)
+
   qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution,measure=False)
   backend = AerSimulator(method = 'statevector')
   output=[]

qlbm/visualize_counts.py

@@ -22,22 +22,73 @@ def bitstring_to_xyz(bs):
     maxv = (1 << t)
     return ix / maxv, iy / maxv, iz / maxv
 
-def load_samples(d,T_total):
+def load_samples(d, T_total, logger=None):
+  """
+  Load samples from measurement counts dictionary.
+  
+  Parameters
+  ----------
+  d : dict
+      Dictionary mapping bitstrings to counts
+  T_total : int
+      Total number of timesteps (used to determine how many direction bits to check)
+  logger : callable, optional
+      Function to log messages
+  
+  Returns
+  -------
+  pts : ndarray
+      Array of (x, y, z) points
+  counts : ndarray
+      Array of counts for each point
+  """
+  def log(msg):
+      if logger:
+          logger(str(msg))
+      else:
+          print(msg)
+  
   pts = []
   counts = []
+  
+  if d is None or len(d) == 0:
+      log("Warning: Empty counts dictionary")
+      return np.array(pts), np.array(counts)
+  
+  # Debug: show sample bitstrings
+  sample_keys = list(d.keys())[:3]
+  log(f"Sample bitstrings (first 3): {sample_keys}")
+  if sample_keys:
+      log(f"Bitstring length: {len(sample_keys[0])}")
+      log(f"Expected prefix length (6*T_total): {6*T_total}")
+  
   for bs, cnt in d.items():
-    if bs[:6*T_total] == "0" * 6*T_total:
-      if cnt<0:
+    # Check if the direction qubits (first 6*T_total bits) are all zeros
+    prefix = bs[:6*T_total]
+    expected_prefix = "0" * 6*T_total
+    
+    if prefix == expected_prefix:
+      if cnt < 0:
          continue
-      x, y, z = bitstring_to_xyz(bs[6*T_total:])
+      remaining_bits = bs[6*T_total:]
+      # Check if remaining bits are divisible by 3
+      if len(remaining_bits) % 3 != 0:
+          log(f"Warning: Remaining bitstring length {len(remaining_bits)} not divisible by 3")
+          continue
+      x, y, z = bitstring_to_xyz(remaining_bits)
       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)
+  log(f"Number of valid counts: {np.sum(counts)}")
+  log(f"Number of valid bitstrings: {len(counts)}")
+  
+  if len(counts) == 0:
+      log("Warning: No bitstrings matched the zero-prefix filter. This may indicate:")
+      log("  - All measurement outcomes had non-zero direction qubits")
+      log("  - Bitstring format mismatch")
+  
   return pts, counts
 
 def estimate_density(pts, counts, bandwidth=0.05, grid_size=64):
@@ -46,12 +97,37 @@ def estimate_density(pts, counts, bandwidth=0.05, grid_size=64):
     Returns (grid_x, grid_y, grid_z, grid_density) where
     grid_x, etc. are 3D mesh arrays, and grid_density has same shape.
     """
+    # Handle empty input
+    if len(pts) == 0 or len(counts) == 0 or np.sum(counts) == 0:
+        print("Warning: No valid samples to estimate density. Returning uniform distribution.")
+        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')
+        dens = np.ones(xx.shape) * 0.001  # Small uniform density
+        return xx, yy, zz, dens
+    
     # 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,
+    # 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)
+    
+    # Handle case where all counts are zero after conversion
+    if len(pts_rep) == 0:
+        print("Warning: No points after replication. Returning uniform distribution.")
+        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')
+        dens = np.ones(xx.shape) * 0.001  # Small uniform density
+        return xx, yy, zz, dens
+    
     kde = KernelDensity(bandwidth=bandwidth, kernel='gaussian')
     kde.fit(pts_rep)