EM: IBM QPU Version

qlbm/qlbm_sample_app.py

@@ -251,7 +251,7 @@ def stream(qc,pos_qr,dir_qr,n):
       qc.cp( np.pi / (2 ** m), forw_ctrl,  pos_qr[i][m])
       qc.cp(-np.pi / (2 ** m), backw_ctrl, pos_qr[i][m])
 
-def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure=True):
+def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure=True,flag_qubits=False,midcircuit_meas=True):
 
   ux_str,uy_str,uz_str=None,None,None
   if type(ux)==str:
@@ -277,17 +277,31 @@ def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure
   for T_total in T_list:
     pos_qr=[QuantumRegister(n) for _ in range(dim)]
     pos_cr=[ClassicalRegister(n) for _ in range(dim)]
-    dir_qr=QuantumRegister(2*dim)
-    dir_cr=[ClassicalRegister(2*dim) for _ in range(T_total)]
+    if midcircuit_meas:
+      dir_qr=QuantumRegister(2*dim)
+    else:
+      dir_qr_list=[QuantumRegister(2*dim) for _ in range(T_total)]
+    dir_qr_flag=QuantumRegister(2*dim)
+    dir_cr=[ClassicalRegister((4 if flag_qubits and midcircuit_meas else 2)*dim) for _ in range(T_total+int(flag_qubits and not midcircuit_meas))]
 
-    qc=QuantumCircuit(*pos_qr,dir_qr,*pos_cr,*dir_cr)
+    if flag_qubits:
+      if midcircuit_meas:
+        qc=QuantumCircuit(*pos_qr,dir_qr,dir_qr_flag,*pos_cr,*dir_cr)
+      else:
+        qc=QuantumCircuit(*pos_qr,*dir_qr_list,dir_qr_flag,*pos_cr,*dir_cr)
+    else:
+      if midcircuit_meas:
+        qc=QuantumCircuit(*pos_qr,dir_qr,*pos_cr,*dir_cr)
+      else:
+        qc=QuantumCircuit(*pos_qr,*dir_qr_list,*pos_cr,*dir_cr)
 
     qc.compose(init_state_prep_circ,[qubit for qr in pos_qr for qubit in list(qr)], inplace=True)
 
     uniform_bool=False
 
-    if 'x' not in ux_str+uy_str+uz_str and 'y' not in ux_str+uy_str+uz_str and 'z' not in ux_str+uy_str+uz_str:
-      uniform_bool=True
+    if ux_str is not None:
+      if 'x' not in ux_str+uy_str+uz_str and 'y' not in ux_str+uy_str+uz_str and 'z' not in ux_str+uy_str+uz_str:
+        uniform_bool=True
     
     if uniform_bool:
       for i in range(dim):
@@ -295,7 +309,14 @@ def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure
 
     for T in list(range(T_total))[::-1]:
 
+      if not midcircuit_meas:
+        dir_qr=dir_qr_list[T]
+
       prep(qc,pos_qr,dir_qr)
+
+      if flag_qubits:
+        for q1,q2 in zip(dir_qr,dir_qr_flag):
+          qc.cx(q1,q2)
       if not uniform_bool:
         for i in range(dim):
           qc.compose(QFT(n, inverse=False, do_swaps=False), pos_qr[i], inplace=True)
@@ -303,9 +324,18 @@ def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure
       if not uniform_bool:
         for i in range(dim):
           qc.compose(QFT(n, inverse=True, do_swaps=False), pos_qr[i], inplace=True)
+      if flag_qubits:
+        for q1,q2 in zip(dir_qr,dir_qr_flag):
+          qc.cx(q1,q2)
       unprep(qc,pos_qr,dir_qr)
 
-      qc.measure(dir_qr,dir_cr[T])
+      if flag_qubits and midcircuit_meas:
+        qc.measure(list(dir_qr)+list(dir_qr_flag),dir_cr[T])
+      else:
+        qc.measure(dir_qr,dir_cr[T])
+
+    if not midcircuit_meas and flag_qubits:
+      qc.measure(dir_qr_flag,dir_cr[T_total])
 
     if uniform_bool:
       for i in range(dim):
@@ -314,7 +344,7 @@ def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure
     if measure:
       for i in range(dim):
         qc.measure(pos_qr[i],pos_cr[i])
-    
+
     qc_list+=[qc]
 
   return qc_list
@@ -481,6 +511,7 @@ def run_sampling_hw_ibm(
     vel_resolution=32,
     output_resolution=40,
     logger=None,
+    flag_qubits=True
 ):
   """
   Run QLBM simulation on IBM quantum hardware.
@@ -525,7 +556,7 @@ def run_sampling_hw_ibm(
   # 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)
+  qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution,flag_qubits=flag_qubits)
 
   pm_optimization_level = 3
 
@@ -545,7 +576,7 @@ def run_sampling_hw_ibm(
   # Create Sampler primitive bound to the backend
   sampler = Sampler(mode=backend)
 
-  # Submit job: pass a list of PUBs (we send one PUB [qc_compiled])
+  # # 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...")
 
@@ -566,7 +597,7 @@ def run_sampling_hw_ibm(
           joined_counts = None
 
       # Suppress verbose logging by passing None as logger
-      pts, counts = load_samples(joined_counts, T_total, logger=None)
+      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)")
@@ -575,6 +606,104 @@ def run_sampling_hw_ibm(
   
   return job,get_job_result
 
+from qiskit_ionq import IonQProvider
+
+provider = IonQProvider("slZCfQN3gptIiuswZ3TULhRu37kOhrlW")
+
+def run_sampling_hw_ionq(
+    n,
+    ux,
+    uy,
+    uz,
+    init_state_prep_circ,
+    T_list,
+    shots=2**19,
+    vel_resolution=32,
+    output_resolution=40,
+    logger=None,
+    flag_qubits=True
+):
+  """
+  Run QLBM simulation on IonQ quantum hardware.
+  
+  Parameters
+  ----------
+  n : int
+      Number of qubits per spatial dimension
+  ux, uy, uz : callable or str
+      Velocity field components
+  init_state_prep_circ : QuantumCircuit
+      Pre-built initial state preparation circuit from get_named_init_state_circuit()
+  T_list : list[int]
+      List of timesteps to simulate
+  shots : int
+      Number of measurement shots (default: 2^19)
+  vel_resolution : int
+      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 : IonQ Job
+      The submitted job object
+  get_job_result : callable
+      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)
+
+  # # 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)
+
+  # backend = provider.get_backend("simulator")
+  backend = provider.get_backend("qpu.forte-enterprise-1")
+
+  qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution,flag_qubits=flag_qubits,midcircuit_meas=False)
+
+  # Create Sampler primitive bound to the backend
+
+  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...")
+
+  def get_job_result(j):
+    
+    log("Waiting for job results (this may take time)...")
+
+    output=[]
+
+    for i,T_total in enumerate(T_list):
+
+      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)")
+    fig = plot_density_isosurface_slider(output, T_list)
+    return output, fig
+  
+  return job,get_job_result
+
+
 
 from qiskit_aer import AerSimulator
 
@@ -936,52 +1065,47 @@ def show_initial_distribution(
 
 if __name__=="__main__":
 
-  n=4
+  n=3
 
-  # # Step 1: Create the initial state circuit ONCE with all parameters
+  # Step 1: Create the initial state circuit ONCE with all parameters
   # init_state_prep_circ = get_named_init_state_circuit(
   #     n=n,
   #     init_state_name="multi_dirac_delta",  # or "gaussian", "dirac_delta"
-  #     sine_k_x=1.0,
-  #     sine_k_y=1.0,
-  #     sine_k_z=1.0
-  #     # gauss_cx=0.5,  # Uncomment for Gaussian
-  #     # gauss_cy=0.5,
-  #     # gauss_cz=0.5,
-  #     # gauss_sigma=0.2,
   # )
-  
-    # Alternative: Run on local simulator
-  output, fig = run_sampling_sim(
-      n=n,
-      ux="sin(-2*pi*z)",
-      uy="1",
-      uz="sin(2*pi*x)",
-      init_state_prep_circ="multi_dirac_delta",
-      T_list=[1,3,5,7,9],
-      vel_resolution=16
-  )
-  print(output)
-  fig.show(renderer="browser")
+
+  # # Alternative: Run on local simulator
+  # output, fig = run_sampling_sim(
+  #     n=n,
+  #     ux="sin(-2*pi*z)",
+  #     uy="1",
+  #     uz="sin(2*pi*x)",
+  #     init_state_prep_circ="multi_dirac_delta",
+  #     T_list=[1,3,5,7,9],
+  #     vel_resolution=16
+  # )
+
+  # print(output)
+
+  # fig.show(renderer="browser")
 
   # Step 2: (Optional) Preview the initial distribution
   # show_initial_distribution(n=n, init_state_name="sin", sine_k_x=1, sine_k_y=1, sine_k_z=1)
 
   # Step 3: Run simulation - pass the pre-built circuit
-  # job, get_job_result = run_sampling_hw_ibm(
-  #     n=n,
-  #     ux=lambda x,y,z: 1,
-  #     uy=lambda x,y,z: 1,
-  #     uz=lambda x,y,z: 1,
-  #     init_state_prep_circ=init_state_prep_circ,  # Pass the circuit directly
-  #     T_list=[1],
-  #     shots=2**19,
-  #     vel_resolution=2,
-  # )
+  job, get_job_result = run_sampling_hw_ionq(
+      n=n,
+      ux="1",
+      uy="1",
+      uz="1",
+      init_state_prep_circ="multi_dirac_delta",  # Pass the circuit directly
+      T_list=[1,2],
+      shots=2**15,
+      vel_resolution=2,
+      output_resolution=16
+  )
 
-  # output = get_job_result(job)
-  # for xx, yy, zz, dens in output:
-  #   plot_density_isosurface(xx, yy, zz, dens)
+  output,fig = get_job_result(job)
+  fig.show(renderer="browser")
 
 
 

qlbm/visualize_counts.py

@@ -22,7 +22,7 @@ def bitstring_to_xyz(bs):
     maxv = (1 << t)
     return ix / maxv, iy / maxv, iz / maxv
 
-def load_samples(d, T_total, logger=None):
+def load_samples(d, T_total, logger=None, flag_qubits=False, midcircuit_meas=True):
   """
   Load samples from measurement counts dictionary.
   
@@ -50,27 +50,37 @@ def load_samples(d, T_total, logger=None):
   
   pts = []
   counts = []
+
+  if flag_qubits:
+    if midcircuit_meas:
+      pref_length=12*T_total
+    else:
+      pref_length=6*(T_total+1)
+  else:
+    pref_length=6*T_total
+      
   
   if d is None or len(d) == 0:
-      log("Warning: Empty counts dictionary")
-      return np.array(pts), np.array(counts)
+    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}")
+    log(f"Bitstring length: {len(sample_keys[0])}")
+    log(f"Expected prefix length: {pref_length}")
   
   for bs, cnt in d.items():
     # Check if the direction qubits (first 6*T_total bits) are all zeros
-    prefix = bs[:6*T_total]
-    expected_prefix = "0" * 6*T_total
+    bs=bs.replace(" ","")
+    prefix = bs[:pref_length]
+    expected_prefix = "0" * pref_length
     
     if prefix == expected_prefix:
       if cnt < 0:
          continue
-      remaining_bits = bs[6*T_total:]
+      remaining_bits = bs[pref_length:]
       # 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")
@@ -146,6 +156,8 @@ def estimate_density(pts, counts, bandwidth=0.05, grid_size=64):
     dens = np.exp(logdens)
     dens = dens.reshape(xx.shape)
 
+    dens = (grid_size**3)*dens/np.sum(dens.flatten())
+
     print("Mins:", mins)
     print("Maxs:", maxs)
     print("dens:", dens)
@@ -220,7 +232,7 @@ def plot_density_isosurface_slider(outputs, T_list=None):
             isomin=global_min,
             isomax=global_max,
             opacity=0.4,
-            surface_count=5,
+            surface_count=10,
             caps=dict(x_show=False, y_show=False, z_show=False),
             colorscale='Blues',
             colorbar=dict(title="Density"),
@@ -257,7 +269,7 @@ def plot_density_isosurface_slider(outputs, T_list=None):
         ),
         sliders=sliders
     )
-    
+
     # fig.show(renderer="browser")
     return fig
 

qlbm_embedded.py

@@ -1189,7 +1189,7 @@ def run_simulation():
                 # shots=2**14, # Reduced shots for responsiveness/quota
                 shots=2**18,
                 vel_resolution=min(params['grid_size'], 32),
-                output_resolution=40,
+                output_resolution=min(2*params['grid_size'], 40),
                 logger=log_to_console
             )