Added optional flag qubit functionality for hw runs; limited output resolution to be at most twice the input resolution

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):
 
   ux_str,uy_str,uz_str=None,None,None
   if type(ux)==str:
@@ -278,16 +278,21 @@ def get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution=32,measure
     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)]
+    dir_qr_flag=QuantumRegister(2*dim)
+    dir_cr=[ClassicalRegister((4 if flag_qubits else 2)*dim) for _ in range(T_total)]
 
-    qc=QuantumCircuit(*pos_qr,dir_qr,*pos_cr,*dir_cr)
+    if flag_qubits:
+      qc=QuantumCircuit(*pos_qr,dir_qr,dir_qr_flag,*pos_cr,*dir_cr)
+    else:
+      qc=QuantumCircuit(*pos_qr,dir_qr,*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):
@@ -296,6 +301,9 @@ 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]:
 
       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 +311,15 @@ 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:
+        qc.measure(list(dir_qr)+list(dir_qr_flag),dir_cr[T])
+      else:
+        qc.measure(dir_qr,dir_cr[T])
 
     if uniform_bool:
       for i in range(dim):
@@ -481,6 +495,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 +540,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 +560,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 +581,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)")
@@ -936,7 +951,7 @@ def show_initial_distribution(
 
 if __name__=="__main__":
 
-  n=4
+  n=3
 
   # # Step 1: Create the initial state circuit ONCE with all parameters
   # init_state_prep_circ = get_named_init_state_circuit(
@@ -951,35 +966,55 @@ if __name__=="__main__":
   #     # 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_ibm(
+      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**19,
+      vel_resolution=2,
+      output_resolution=8,
+      flag_qubits=True
+  )
+
+  # from qiskit_ibm_runtime import QiskitRuntimeService
+
+  # service = QiskitRuntimeService(
+  #     channel='ibm_quantum_platform', token="UMeZUDI5D7fjPJHD5x3MJFwURg4PrGzBnTm142ka9-Hj",
+  #     instance='crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::'
   # )
+  # job = service.job('d4spkn3her1c73bdjelg')
+  # job_result = job.result()
+
+  # To get counts for a particular pub result, use
+  #
+  # pub_result = job_result[<idx>].data.<classical register>.get_counts()
+  #
+  # where <idx> is the index of the pub and <classical register> is the name of the classical register.
+  # You can use circuit.cregs to find the name of the classical registers.
+
+  output,fig = get_job_result(job)
+  fig.show(renderer="browser")
 
-  # output = get_job_result(job)
   # for xx, yy, zz, dens in output:
   #   plot_density_isosurface(xx, yy, zz, dens)
 

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):
   """
   Load samples from measurement counts dictionary.
   
@@ -50,6 +50,10 @@ def load_samples(d, T_total, logger=None):
   
   pts = []
   counts = []
+
+  pref_length=6*T_total
+  if flag_qubits:
+      pref_length=12*T_total
   
   if d is None or len(d) == 0:
       log("Warning: Empty counts dictionary")
@@ -60,17 +64,17 @@ def load_samples(d, T_total, logger=None):
   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"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
+    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 +150,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 +226,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 +263,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
             )