Feature :(QLBM: IBM Qiskit Simulator )

qlbm/qlbm_sample_app.py

@@ -0,0 +1,901 @@
+from qiskit import QuantumCircuit,QuantumRegister,ClassicalRegister,transpile
+from qiskit.synthesis.qft import synth_qft_full as QFT
+import numpy as np
+
+
+from sympy import sympify, symbols, lambdify
+
+
+from qiskit_ibm_runtime import QiskitRuntimeService
+
+import plotly.graph_objects as go
+
+dim=3
+
+
+def bin_to_gray(bin_s):
+  XOR=lambda x,y: (x or y) and not (x and y) 
+  gray_s=bin_s[0] 
+  for i in range(len(bin_s)-1): 
+    c_bool=XOR(bool(int(bin_s[i])),bool(int(bin_s[i+1]))) 
+    gray_s+=str(int(c_bool)) 
+  return gray_s
+
+def gray_to_bin(gray_s):
+  XOR=lambda x,y: (x or y) and not (x and y) 
+  bin_s=gray_s[0] 
+  for i in range(len(gray_s)-1): 
+    c_bool=XOR(bool(int(bin_s[i])),bool(int(gray_s[i+1]))) 
+    bin_s+=str(int(c_bool)) 
+  return bin_s
+
+def bin_to_int(bin_s):
+  return int(bin_s,2)
+
+def int_to_bin(i,pad):
+  return bin(i)[2:].zfill(pad)
+
+def fwht_approx(f,N,num_points_per_dim,threshold=1e-10):
+  linear_block_size=int(N//num_points_per_dim)
+  num_angles_per_block=int(np.log2(linear_block_size))
+
+  thetas={}
+
+  for k in range(num_points_per_dim):
+    for j in range(num_points_per_dim):
+      for i in range(num_points_per_dim):
+
+        avg_f=2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2))
+        thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size]=avg_f
+
+        slope_x=(2*np.arccos(f(i*linear_block_size,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2))-2*np.arccos(f(((i+1)%N)*linear_block_size,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size+(linear_block_size-1)/2)))/linear_block_size
+        slope_y=(2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size,k*linear_block_size+(linear_block_size-1)/2))-2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,((j+1)%N)*linear_block_size,k*linear_block_size+(linear_block_size-1)/2)))/linear_block_size
+        slope_z=(2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,k*linear_block_size))-2*np.arccos(f(i*linear_block_size+(linear_block_size-1)/2,j*linear_block_size+(linear_block_size-1)/2,((k+1)%N)*linear_block_size)))/linear_block_size
+
+        for m in range(num_angles_per_block):
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + 2**m]=slope_x*(2**(m-1))
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + N*(2**m)]=slope_y*(2**(m-1))
+          thetas[k*(N**2)*linear_block_size+j*N*linear_block_size+i*linear_block_size + (N**2)*(2**m)]=slope_z*(2**(m-1))
+
+  h = linear_block_size
+  while h < N**3:
+    for i in range(0, N**3, h * 2):
+      if (i//N)%linear_block_size!=0:
+        continue
+      if (i//(N**2))%linear_block_size!=0:
+        continue
+      j=i
+      while j<i+h:
+        index=j
+        x = thetas[index]
+        y = thetas[index + h]
+        thetas[index] = (x + y)/2
+        thetas[index + h] = (x - y)/2
+
+        for ax in range(3):
+          for m in range(num_angles_per_block):
+            index=j+(N**ax)*(2**m)
+            x = thetas[index]
+            y = thetas[index + h]
+            thetas[index] = (x + y)/2
+            thetas[index + h] = (x - y)/2
+
+        j+=linear_block_size
+        if (j//N)%linear_block_size==1:
+          j+=(linear_block_size-1)*N
+        if (j//(N**2))%linear_block_size==1:
+          j+=(linear_block_size-1)*(N**2)
+
+    h *= 2
+    if h==N:
+      h=N*linear_block_size
+    if h==N**2:
+      h=(N**2)*linear_block_size
+    
+  theta_sorted=sorted(np.abs(list(thetas.values())))
+  
+  sum_=0
+  for th in theta_sorted:
+    sum_+=th
+    if sum_>threshold:
+      threshold=sum_-th
+      break
+
+  return [theta for theta in thetas.values() if abs(theta)>threshold],[key for key in thetas.keys() if abs(thetas[key])>threshold]
+
+def get_circuit_inputs(f,num_reg_qubits,num_points_per_dim):
+  theta_vec,indices=fwht_approx(f,2**num_reg_qubits,num_points_per_dim,1e-4)
+  circ_pos=[]
+  for ind in indices:
+    circ_pos+=[bin_to_int(gray_to_bin(int_to_bin(ind,num_reg_qubits*3)))]
+
+  sorted_theta_vec=sorted(zip(theta_vec,circ_pos),key=lambda el:el[1])
+  ctrls=[]
+
+  current_bs="0"*(3*num_reg_qubits)
+  for el in sorted_theta_vec:
+    new_bs=bin_to_gray(int_to_bin((el[1])%(2**(3*num_reg_qubits)),(3*num_reg_qubits)))
+    ctrls += [[i for i, (char1, char2) in enumerate(zip(current_bs[::-1], new_bs[::-1])) if char1 != char2]]
+    current_bs=new_bs
+  new_bs="0"*(3*num_reg_qubits)
+  ctrls += [[i for i, (char1, char2) in enumerate(zip(current_bs[::-1], new_bs[::-1])) if char1 != char2]]
+
+  return [el[0] for el in sorted_theta_vec],ctrls
+
+
+def get_coeffs(n,ux,uy,uz,resolution=32):
+  current_N=2**n
+
+  x_coeffs,x_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+ux(x/current_N,y/current_N,z/current_N))/2)**0.5,n,min(current_N,resolution))
+  y_coeffs,y_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+uy(x/current_N,y/current_N,z/current_N))/2)**0.5,n,min(current_N,resolution))
+  z_coeffs,z_coeff_var_indices=get_circuit_inputs(lambda x,y,z: ((1+uz(x/current_N,y/current_N,z/current_N))/2)**0.5,n,min(current_N,resolution))
+  x_coeffs_,x_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+ux((x-1)/current_N,y/current_N,z/current_N))==0 else \
+                          ((1+ux((x-1)/current_N,y/current_N,z/current_N))/(2+ux((x-1)/current_N,y/current_N,z/current_N)-ux((x+1)/current_N,y/current_N,z/current_N)))**0.5,n,min(current_N,resolution))
+  y_coeffs_,y_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+uy(x/current_N,(y-1)/current_N,z/current_N))==0 else \
+                          ((1+uy(x/current_N,(y-1)/current_N,z/current_N))/(2+uy(x/current_N,(y-1)/current_N,z/current_N)-uy(x/current_N,(y+1)/current_N,z/current_N)))**0.5,n,min(current_N,resolution))
+  z_coeffs_,z_coeff_var_indices_=get_circuit_inputs(lambda x,y,z: 0 if (1+uz(x/current_N,y/current_N,(z-1)/current_N))==0 else \
+                          ((1+uz(x/current_N,y/current_N,(z-1)/current_N))/(2+uz(x/current_N,y/current_N,(z-1)/current_N)-uz(x/current_N,y/current_N,(z+1)/current_N)))**0.5,n,min(current_N,resolution))
+  unprep1_coeffs,unprep1_coeff_var_indices=get_circuit_inputs(lambda x,y,z:\
+                          (1/3**0.5)*(1+(ux((x-1)/current_N,y/current_N,z/current_N)-ux((x+1)/current_N,y/current_N,z/current_N))/2)**0.5,n,min(current_N,resolution))
+  unprep2_coeffs,unprep2_coeff_var_indices=get_circuit_inputs(lambda x,y,z:\
+                          ((1+(uy(x/current_N,(y-1)/current_N,z/current_N)-uy(x/current_N,(y+1)/current_N,z/current_N))/2)/(2-(ux((x-1)/current_N,y/current_N,z/current_N)-ux((x+1)/current_N,y/current_N,z/current_N))/2))**0.5,n,min(current_N,resolution))
+  
+  return x_coeffs,x_coeff_var_indices, y_coeffs,y_coeff_var_indices, z_coeffs,z_coeff_var_indices,\
+         x_coeffs_,x_coeff_var_indices_, y_coeffs_,y_coeff_var_indices_, z_coeffs_,z_coeff_var_indices_,\
+         unprep1_coeffs,unprep1_coeff_var_indices, unprep2_coeffs,unprep2_coeff_var_indices
+
+
+def get_coll_ops(n,ux,uy,uz,resolution=32):
+    
+  x_coeffs,x_coeff_var_indices, y_coeffs,y_coeff_var_indices, z_coeffs,z_coeff_var_indices,\
+  x_coeffs_,x_coeff_var_indices_, y_coeffs_,y_coeff_var_indices_, z_coeffs_,z_coeff_var_indices_,\
+  unprep1_coeffs,unprep1_coeff_var_indices, unprep2_coeffs,unprep2_coeff_var_indices = get_coeffs(n,ux,uy,uz,resolution)
+
+  def prep(qc,pos_qr,dir_qr):
+
+    qc.h(dir_qr[0])
+    qc.h(dir_qr[4])
+
+    qc.cx(dir_qr[0],dir_qr[2])
+
+    qc.ry(-np.pi/4,dir_qr[4])
+    qc.cx(dir_qr[2],dir_qr[4])
+    qc.ry(np.pi/4,dir_qr[4])
+    qc.cx(dir_qr[2],dir_qr[4])
+
+    qc.ry(-np.pi/4,dir_qr[2])
+    qc.cx(dir_qr[0],dir_qr[2])
+    qc.ry(np.pi/4,dir_qr[2])
+    qc.cx(dir_qr[0],dir_qr[2])
+
+    qc.cx(dir_qr[2],dir_qr[0])
+
+    qc.cx(dir_qr[0],dir_qr[1])
+    for i in range(len(x_coeff_var_indices)):
+      for ind in x_coeff_var_indices[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[0])
+      if i<len(x_coeffs):
+        qc.cry(x_coeffs[i],dir_qr[1],dir_qr[0])
+    qc.cx(dir_qr[0],dir_qr[1])
+
+    qc.cx(dir_qr[2],dir_qr[3])
+    for i in range(len(y_coeff_var_indices)):
+      for ind in y_coeff_var_indices[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[2])
+      if i<len(y_coeffs):
+        qc.cry(y_coeffs[i],dir_qr[3],dir_qr[2])
+    qc.cx(dir_qr[2],dir_qr[3])
+
+    qc.cx(dir_qr[4],dir_qr[5])
+    for i in range(len(z_coeff_var_indices)):
+      for ind in z_coeff_var_indices[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[4])
+      if i<len(z_coeffs):
+        qc.cry(z_coeffs[i],dir_qr[5],dir_qr[4])
+    qc.cx(dir_qr[4],dir_qr[5])
+
+
+
+  def unprep(qc,pos_qr,dir_qr):
+    qc.cx(dir_qr[0],dir_qr[1])
+    for i in range(len(x_coeff_var_indices_)):
+      for ind in x_coeff_var_indices_[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[0])
+      if i<len(x_coeffs_):
+        qc.cry(-x_coeffs_[i],dir_qr[1],dir_qr[0])
+    qc.cx(dir_qr[0],dir_qr[1])
+
+    qc.cx(dir_qr[2],dir_qr[3])
+    for i in range(len(y_coeff_var_indices_)):
+      for ind in y_coeff_var_indices_[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[2])
+      if i<len(y_coeffs_):
+        qc.cry(-y_coeffs_[i],dir_qr[3],dir_qr[2])
+    qc.cx(dir_qr[2],dir_qr[3])
+
+    qc.cx(dir_qr[4],dir_qr[5])
+    for i in range(len(z_coeff_var_indices_)):
+      for ind in z_coeff_var_indices_[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[4])
+      if i<len(z_coeffs_):
+        qc.cry(-z_coeffs_[i],dir_qr[5],dir_qr[4])
+    qc.cx(dir_qr[4],dir_qr[5])
+
+    qc.cx(dir_qr[2],dir_qr[4])
+    for i in range(len(unprep2_coeff_var_indices)):
+      for ind in unprep2_coeff_var_indices[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[2])
+      if i<len(unprep2_coeffs):
+        qc.cry(unprep2_coeffs[i],dir_qr[4],dir_qr[2])
+    qc.cx(dir_qr[2],dir_qr[4])
+
+    qc.cx(dir_qr[0],dir_qr[2])
+    for i in range(len(unprep1_coeff_var_indices)):
+      for ind in unprep1_coeff_var_indices[i]:
+        qc.cx([q for reg in pos_qr for q in reg][ind],dir_qr[0])
+      if i<len(unprep1_coeffs):
+        qc.cry(unprep1_coeffs[i],dir_qr[2],dir_qr[0])
+    qc.cx(dir_qr[0],dir_qr[2])
+
+    qc.ry(-2*np.pi/3,dir_qr[0])
+
+
+  return prep,unprep
+
+def stream(qc,pos_qr,dir_qr,n):
+
+  for i in range(dim):
+    forw_ctrl=dir_qr[2*i]
+    backw_ctrl=dir_qr[2*i+1]
+    for m in range(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):
+
+
+  dirs=[[0,0,0],[1,0,0],[-1,0,0],[0,1,0],[0,-1,0],[0,0,1],[0,0,-1]]
+  wts = np.array([2/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8])
+
+  dir_indices=["".join(["0"+str(el) if el>=0 else str(-el)+"0" for el in dir_[::-1]]) for dir_ in dirs]
+  dirs_state=np.zeros(2**7)
+  for i,dir_ind in enumerate(dir_indices):
+    ind=int(dir_ind,2)
+    dirs_state[ind]=wts[i]**0.5
+
+  qc_list=[]
+
+  prep, unprep=get_coll_ops(n,ux,uy,uz,vel_resolution)
+
+  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)]
+
+    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)
+
+
+    for i in range(dim):
+      qc.compose(QFT(n, inverse=False, do_swaps=False), pos_qr[i], inplace=True)
+
+    for T in list(range(T_total))[::-1]:
+
+      prep(qc,pos_qr,dir_qr)
+      stream(qc,pos_qr,dir_qr,n)
+      unprep(qc,pos_qr,dir_qr)
+
+      qc.measure(dir_qr,dir_cr[T])
+
+    for i in range(dim):
+      qc.compose(QFT(n, inverse=True, do_swaps=False), pos_qr[i], inplace=True)
+
+    if measure:
+      for i in range(dim):
+        qc.measure(pos_qr[i],pos_cr[i])
+    
+    qc_list+=[qc]
+
+  return qc_list
+
+
+
+def str_to_lambda(vx_param,vy_param,vz_param):
+
+  vx_val = str(vx_param)
+  vy_val = str(vy_param)
+  vz_val = str(vz_param)
+
+  x_sym, y_sym, z_sym = symbols('x y z')
+  vx_sympified = sympify(vx_val)
+  vy_sympified = sympify(vy_val)
+  vz_sympified = sympify(vz_val)
+
+  vx=lambdify((x_sym, y_sym, z_sym), vx_sympified, modules="numpy")
+  vy=lambdify((x_sym, y_sym, z_sym), vy_sympified, modules="numpy")
+  vz=lambdify((x_sym, y_sym, z_sym), vz_sympified, modules="numpy")
+
+  return vx,vy,vz
+
+
+def get_named_init_state_circuit(
+    n: int,
+    init_state_name: str,
+    # Sinusoidal parameters (frequency multipliers)
+    sine_k_x: float = 1.0,
+    sine_k_y: float = 1.0,
+    sine_k_z: float = 1.0,
+    # Gaussian parameters
+    gauss_cx: float = None,  # Center X (0-1 normalized), defaults to 0.5
+    gauss_cy: float = None,  # Center Y (0-1 normalized), defaults to 0.5
+    gauss_cz: float = None,  # Center Z (0-1 normalized), defaults to 0.5
+    gauss_sigma: float = None,  # Spread, defaults to 0.2 in normalized units
+):
+  """
+  Create initial state preparation circuit with configurable parameters.
+  
+  Parameters
+  ----------
+  n : int
+      Number of qubits per spatial dimension (grid size = 2^n per axis)
+  init_state_name : str
+      One of "dirac_delta", "sin", "gaussian"
+  sine_k_x, sine_k_y, sine_k_z : float
+      Frequency multipliers for sinusoidal distribution (default=1.0)
+  gauss_cx, gauss_cy, gauss_cz : float
+      Center coordinates in [0,1] for Gaussian (default=0.5)
+  gauss_sigma : float
+      Spread of Gaussian in normalized units (default=0.2)
+  
+  Returns
+  -------
+  QuantumCircuit
+      State preparation circuit
+  """
+  N = 2**n
+  init_state_prep_circ = QuantumCircuit(3*n)
+
+  if init_state_name == "dirac_delta":
+    init_state_prep_circ.x(n-1)
+    init_state_prep_circ.x(2*n-1)
+    init_state_prep_circ.x(3*n-1)
+
+  elif init_state_name == "sin":
+    # Configurable frequency sinusoidal distribution
+    # f(x,y,z) = 1 + sin(2π * kx * x) * sin(2π * ky * y) * sin(2π * kz * z)
+    kx = max(1, int(round(float(sine_k_x))))
+    ky = max(1, int(round(float(sine_k_y))))
+    kz = max(1, int(round(float(sine_k_z))))
+    
+    coords = np.arange(N) / N  # Normalized [0, 1)
+    
+    sin_x = np.sin(2 * np.pi * kx * coords)
+    sin_y = np.sin(2 * np.pi * ky * coords)
+    sin_z = np.sin(2 * np.pi * kz * coords)
+    
+    # Build 3D state via Kronecker products
+    # Order matches original: z ⊗ (y ⊗ x)
+    init_state = 1 + (
+        np.kron(sin_z, np.ones(N**2)) *
+        np.kron(np.ones(N**2), sin_x) *
+        np.kron(np.ones(N), np.kron(sin_y, np.ones(N)))
+    )
+
+    init_state_prep_circ.prepare_state(init_state.astype(np.complex128), normalize=True)
+    init_state_prep_circ = transpile(init_state_prep_circ, basis_gates=['u1', 'u2', 'u3', 'cx'])
+
+  elif init_state_name == "gaussian":
+    # 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)
+    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
+    
+    coords = np.arange(N) / N  # Normalized [0, 1)
+    
+    gauss_x = np.exp(-((coords - cx)**2) / (2 * sigma**2))
+    gauss_y = np.exp(-((coords - cy)**2) / (2 * sigma**2))
+    gauss_z = np.exp(-((coords - cz)**2) / (2 * sigma**2))
+    
+    # Build 3D state via Kronecker products (same order as original)
+    init_state = (
+        np.kron(gauss_z, np.ones(N**2)) *
+        np.kron(np.ones(N**2), gauss_x) *
+        np.kron(np.ones(N), np.kron(gauss_y, np.ones(N)))
+    )
+
+    init_state_prep_circ.prepare_state(init_state.astype(np.complex128), normalize=True)
+    init_state_prep_circ = transpile(init_state_prep_circ, basis_gates=['u1', 'u2', 'u3', 'cx'])
+
+  return init_state_prep_circ
+
+
+##########################################################################################
+
+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
+
+
+def run_sampling_hw_ibm(
+    n,
+    ux,
+    uy,
+    uz,
+    init_state_prep_circ,
+    T_list,
+    shots=2**19,
+    vel_resolution=32,
+    output_resolution=40,
+):
+  """
+  Run QLBM simulation on IBM 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
+  
+  Returns
+  -------
+  job : IBMJob
+      The submitted job object
+  get_job_result : callable
+      Callback function to retrieve and process results
+  """
+
+  if type(ux)==str:
+    ux,uy,uz=str_to_lambda(ux,uy,uz)
+
+  qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution)
+
+  pm_optimization_level = 3
+
+  service = QiskitRuntimeService(channel="ibm_cloud", token="UMeZUDI5D7fjPJHD5x3MJFwURg4PrGzBnTm142ka9-Hj",instance="crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::")         # reads stored credentials / environment
+  backend = service.least_busy()
+
+  qc_compiled_list=[]
+
+  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).")
+    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())
+    qc_compiled_list+=[qc_compiled]
+
+  # Create Sampler primitive bound to the backend
+  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)
+  print("Job submitted; waiting for result...")
+
+  def get_job_result(j):
+    result = j.result()   # PrimitiveResult (a container of PubResults)
+    print(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>")
+
+      # 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]})
+      except Exception as e:
+          print("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]})
+      except Exception as e:
+          print("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
+  
+  return job,get_job_result
+
+
+from qiskit_aer import AerSimulator
+
+
+def run_sampling_sim(
+    n,
+    ux,
+    uy,
+    uz,
+    init_state_prep_circ,
+    T_list,
+    vel_resolution=32,
+):
+  """
+  Run QLBM simulation on local Aer statevector simulator.
+  
+  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
+  vel_resolution : int
+      Resolution for velocity field discretization
+  
+  Returns
+  -------
+  output : list[ndarray]
+      List of 3D density arrays, one per timestep
+  fig : go.Figure
+      Plotly figure with slider animation through all timesteps
+  """
+  
+  if type(ux)==str:
+    ux,uy,uz=str_to_lambda(ux,uy,uz)
+
+  qc_list=get_circuit(n,ux,uy,uz,init_state_prep_circ,T_list,vel_resolution,measure=False)
+  backend = AerSimulator(method = 'statevector')
+  output=[]
+
+  for qc in qc_list:
+    qc_transpiled=qc
+    qc_transpiled.save_statevector(conditional=True)
+
+    # Try multiple shots to find a successful (zero-branch) outcome
+    max_attempts = 10
+    success = False
+    
+    for attempt in range(max_attempts):
+      job = backend.run(qc_transpiled, memory=True, shots=1)
+      result = job.result()
+      data_all = result.data()
+      
+      statevector_keys = list(dict(data_all['statevector']).keys())
+      
+      # Look for the zero branch (0x0)
+      zero_key = None
+      for key in statevector_keys:
+        if '0x' in key:
+          if int(key[2:], 16) == 0:
+            zero_key = key
+            break
+        elif key == '0' or key == '00' or key.replace('0', '') == '':
+          zero_key = key
+          break
+      
+      if zero_key is not None:
+        success = True
+        break
+      
+      if attempt < max_attempts - 1:
+        print(f"Attempt {attempt + 1} failed (got branch {statevector_keys[0]}), retrying...")
+    
+    if not success:
+      # If all attempts failed, use the first available branch with a warning
+      print(f"Warning: Could not get zero branch after {max_attempts} attempts. Using first available branch.")
+      zero_key = statevector_keys[0]
+    
+    zero_branch_state = data_all['statevector'][zero_key]
+    sv_mean=np.mean(np.array(zero_branch_state)[:(2**n)**dim])
+    sv_phase=sv_mean/np.abs(sv_mean)
+
+    final_answer = np.real(np.array(zero_branch_state)[:(2**n)**dim]/sv_phase)
+
+    C = np.reshape(np.array(final_answer),tuple(2**n for _ in range(dim)))
+    output+=[C]
+
+  # Create meshgrid for coordinates (used for plotting)
+  x_coords = np.linspace(0, 1, 2**n)
+  X = np.meshgrid(x_coords, x_coords, x_coords, indexing='ij')
+
+  # Create figure with slider for all timesteps
+  fig = _create_slider_figure(output, T_list, X)
+  return output, fig
+
+
+def _create_slider_figure(output_list, T_list, X):
+  """
+  Create a Plotly figure with slider to animate through timesteps.
+  Uses visibility toggling instead of frames for better compatibility.
+  
+  Parameters
+  ----------
+  output_list : list[ndarray]
+      List of 3D density arrays from simulation
+  T_list : list[int]
+      List of timestep values
+  X : tuple of ndarrays
+      Meshgrid coordinates
+  
+  Returns
+  -------
+  fig : go.Figure
+      Plotly figure with slider animation
+  """
+  # Compute global min/max for consistent color scaling
+  global_min = min(np.min(C) for C in output_list)
+  global_max = max(np.max(C) for C in output_list)
+  
+  fig = go.Figure()
+
+  # Add a trace for each timestep
+  for i, (C, T) in enumerate(zip(output_list, T_list)):
+    visible = (i == 0)  # Only the first trace is visible initially
+    fig.add_trace(go.Isosurface(
+      x=X[2].flatten(),
+      y=X[1].flatten(),
+      z=X[0].flatten(),
+      value=C.flatten(),
+      isomin=global_min,
+      isomax=global_max,
+      opacity=0.4,
+      surface_count=10,
+      caps=dict(x_show=False, y_show=False, z_show=False),
+      colorscale='Viridis',
+      colorbar=dict(title="Density"),
+      visible=visible,
+      name=f"T={T}"
+    ))
+
+  # Create slider steps
+  steps = []
+  for i, T in enumerate(T_list):
+    # Create visibility array: only the i-th trace is True
+    step = dict(
+      method="update",
+      args=[{"visible": [False] * len(output_list)},
+            {"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
+  )
+  
+  return fig
+
+
+def show_initial_distribution(
+    n: int,
+    init_state_name: str,
+    # Sinusoidal parameters (frequency multipliers)
+    sine_k_x: float = 1.0,
+    sine_k_y: float = 1.0,
+    sine_k_z: float = 1.0,
+    # Gaussian parameters
+    gauss_cx: float = None,
+    gauss_cy: float = None,
+    gauss_cz: float = None,
+    gauss_sigma: float = None,
+    # Display options
+    plot: bool = True,
+    return_data: bool = False,
+):
+  """
+  Visualize the initial distribution by running the state preparation circuit
+  from get_named_init_state_circuit and extracting the resulting statevector.
+  
+  Parameters
+  ----------
+  n : int
+      Number of qubits per spatial dimension (grid size = 2^n per axis)
+  init_state_name : str
+      One of "dirac_delta", "sin", "gaussian"
+  sine_k_x, sine_k_y, sine_k_z : float
+      Frequency multipliers for sinusoidal distribution (default=1.0)
+  gauss_cx, gauss_cy, gauss_cz : float
+      Center coordinates in [0,1] for Gaussian (default=0.5)
+  gauss_sigma : float
+      Spread of Gaussian in normalized units (default=0.2)
+  plot : bool
+      Whether to display the 3D isosurface plot (default=True)
+  return_data : bool
+      Whether to return the distribution data (default=False)
+  
+  Returns
+  -------
+  If return_data is True:
+      C : ndarray
+          3D array of shape (2^n, 2^n, 2^n) containing the initial distribution
+      X : tuple of ndarrays
+          Meshgrid coordinates (X[0], X[1], X[2]) for x, y, z axes
+  If return_data is False:
+      None
+  """
+  N = 2**n
+  
+  # Get the state preparation circuit from get_named_init_state_circuit
+  init_state_prep_circ = get_named_init_state_circuit(
+      n,
+      init_state_name,
+      sine_k_x=sine_k_x,
+      sine_k_y=sine_k_y,
+      sine_k_z=sine_k_z,
+      gauss_cx=gauss_cx,
+      gauss_cy=gauss_cy,
+      gauss_cz=gauss_cz,
+      gauss_sigma=gauss_sigma,
+  )
+  
+  # Run the circuit on statevector simulator to extract the initial state
+  backend = AerSimulator(method='statevector')
+  
+  # Create a copy of the circuit and save statevector
+  qc = init_state_prep_circ.copy()
+  qc.save_statevector()
+  
+  job = backend.run(qc, shots=1)
+  result = job.result()
+  statevector = np.array(result.get_statevector())
+  
+  # The statevector represents the initial distribution (amplitudes)
+  # Take the real part of the amplitudes (they should be real for these distributions)
+  init_state = np.real(statevector)
+  
+  # Reshape to 3D grid
+  C = np.reshape(init_state, (N, N, N))
+  
+  # Create meshgrid for coordinates
+  x_coords = np.linspace(0, 1, N)
+  X = np.meshgrid(x_coords, x_coords, x_coords, indexing='ij')
+  
+  if plot:
+    print(f"Initial distribution: {init_state_name}")
+    print(f"Grid size: {N} x {N} x {N}")
+    if init_state_name == "sin":
+      print(f"Sine frequencies: kx={sine_k_x}, ky={sine_k_y}, kz={sine_k_z}")
+    elif init_state_name == "gaussian":
+      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
+      sigma = float(gauss_sigma) if gauss_sigma is not None else 0.2
+      print(f"Gaussian center: ({cx}, {cy}, {cz}), sigma={sigma}")
+    
+    print("Distribution stats:")
+    print(f"  Min: {np.min(C):.6f}, Max: {np.max(C):.6f}")
+    print(f"  Mean: {np.mean(C):.6f}, Std: {np.std(C):.6f}")
+    
+    Cmax, Cmin = np.max(C.flatten()), np.min(C.flatten())
+    
+    fig = go.Figure(data=go.Isosurface(
+      x=X[2].flatten(),
+      y=X[1].flatten(),
+      z=X[0].flatten(),
+      value=C.flatten(),
+      isomin=Cmin,
+      isomax=Cmax,
+      opacity=0.4,
+      surface_count=10,
+      caps=dict(x_show=False, y_show=False, z_show=False),
+      colorscale='Viridis',
+    ))
+    
+    fig.update_layout(
+      title=f"Initial Distribution: {init_state_name}",
+      scene=dict(
+        xaxis_title="X",
+        yaxis_title="Y",
+        zaxis_title="Z",
+      ),
+    )
+    
+    fig.show()
+  
+  if return_data:
+    return C, X
+  
+  return None
+
+
+if __name__=="__main__":
+
+  n=3
+  # plot = show_initial_distribution(
+  #     n=n,
+  #     init_state_name="sin",
+  #     sine_k_x=1.0,
+  #     sine_k_y=1.0,
+  #     sine_k_z=1.0,
+  #     plot=True,
+  #     return_data=False
+  # )
+  
+  # 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="sin",  # 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*y)*sin(2*pi*z)",
+      uy="sin(2*pi*x)*sin(2*pi*z)",
+      uz="sin(2*pi*x)*sin(2*pi*y)",
+      init_state_prep_circ=init_state_prep_circ,
+      T_list=[1,3,5],
+      vel_resolution=2
+  )
+  fig.show()
+
+  # 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,
+  # )
+
+  # output = get_job_result(job)
+  # for xx, yy, zz, dens in output:
+  #   plot_density_isosurface(xx, yy, zz, dens)
+
+
+

qlbm_embedded.py

@@ -22,7 +22,23 @@ from pyvista.trame.ui import plotter_ui
 # Set offscreen before pyvista usage
 pv.OFF_SCREEN = True
 
-# --- Backend Detection ---
+# --- Qiskit Backend Detection ---
+_QISKIT_BACKEND_AVAILABLE = False
+_QISKIT_IMPORT_ERROR = None
+
+try:
+    from qlbm.qlbm_sample_app import (
+        run_sampling_sim,
+        get_named_init_state_circuit,
+        str_to_lambda,
+        _create_slider_figure,
+    )
+    _QISKIT_BACKEND_AVAILABLE = True
+except ImportError as e:
+    _QISKIT_IMPORT_ERROR = str(e)
+    print(f"Qiskit backend not available: {e}")
+
+# --- CUDA-Q Backend Detection ---
 def _env_flag(name: str) -> bool:
     return os.environ.get(name, "").strip().lower() in ("1", "true", "yes")
 
@@ -182,6 +198,11 @@ def init_state():
         
         # Pick point text
         "qlbm_pick_text": "",
+        
+        # Qiskit backend state
+        "qlbm_qiskit_mode": False,  # True when using Qiskit backend (shows Plotly slider)
+        "qlbm_qiskit_backend_available": _QISKIT_BACKEND_AVAILABLE,
+        "qlbm_qiskit_fig": None,  # Stores the Plotly figure for Qiskit results
     })
     _initialized = True
 
@@ -810,6 +831,142 @@ def export_simulation_mp4():
                 pass
 
 
+# --- Qiskit Simulation Functions ---
+def _map_state_to_qiskit_params():
+    """
+    Map qlbm_embedded state variables to qlbm_sample_app parameters.
+    
+    Returns
+    -------
+    dict or None
+        Dictionary of parameters for run_sampling_sim, or None if state is unavailable
+    """
+    if _state is None:
+        return None
+    
+    # Map distribution type
+    dist_type = _state.qlbm_dist_type
+    if dist_type == "Sinusoidal":
+        init_state_name = "sin"
+    elif dist_type == "Gaussian":
+        init_state_name = "gaussian"
+    else:
+        init_state_name = "sin"  # Default
+    
+    # Calculate n from grid_size (grid_size = 2^n)
+    grid_size = int(_state.qlbm_grid_size)
+    n = int(math.log2(grid_size)) if grid_size > 0 else 3
+    
+    # Map Gaussian parameters from grid units to normalized [0,1]
+    # In the UI, gauss_cx/cy/cz are in grid units (0 to nx)
+    # qlbm_sample_app expects normalized [0,1]
+    nx = float(_state.qlbm_nx) if _state.qlbm_nx else float(grid_size)
+    gauss_cx = float(_state.qlbm_gauss_cx) / nx if nx > 0 else 0.5
+    gauss_cy = float(_state.qlbm_gauss_cy) / nx if nx > 0 else 0.5
+    gauss_cz = float(_state.qlbm_gauss_cz) / nx if nx > 0 else 0.5
+    gauss_sigma = float(_state.qlbm_gauss_sigma) / nx if nx > 0 else 0.2
+    
+    # Create T_list from time_steps: [1, 2, 3, ..., T]
+    time_steps = int(_state.qlbm_time_steps)
+    if time_steps <= 0:
+        T_list = [1]
+    else:
+        T_list = list(range(1, time_steps + 1))
+    
+    return {
+        "n": n,
+        "init_state_name": init_state_name,
+        "sine_k_x": float(_state.qlbm_sine_k_x),
+        "sine_k_y": float(_state.qlbm_sine_k_y),
+        "sine_k_z": float(_state.qlbm_sine_k_z),
+        "gauss_cx": gauss_cx,
+        "gauss_cy": gauss_cy,
+        "gauss_cz": gauss_cz,
+        "gauss_sigma": gauss_sigma,
+        "vx_expr": str(_state.qlbm_vx_expr),
+        "vy_expr": str(_state.qlbm_vy_expr),
+        "vz_expr": str(_state.qlbm_vz_expr),
+        "T_list": T_list,
+        "grid_size": grid_size,
+    }
+
+
+def _run_qiskit_simulation(progress_callback=None):
+    """
+    Run QLBM simulation using Qiskit Aer statevector simulator.
+    
+    Parameters
+    ----------
+    progress_callback : callable, optional
+        Function to report progress (0-100)
+    
+    Returns
+    -------
+    output : list[ndarray]
+        List of 3D density arrays, one per timestep
+    fig : go.Figure
+        Plotly figure with slider animation
+    T_list : list[int]
+        List of timesteps
+    """
+    if not _QISKIT_BACKEND_AVAILABLE:
+        raise RuntimeError(f"Qiskit backend not available: {_QISKIT_IMPORT_ERROR}")
+    
+    params = _map_state_to_qiskit_params()
+    if params is None:
+        raise RuntimeError("Failed to map state parameters")
+    
+    log_to_console(f"Qiskit Simulation Parameters:")
+    log_to_console(f"  n={params['n']} (grid {params['grid_size']}³)")
+    log_to_console(f"  T_list={params['T_list']}")
+    log_to_console(f"  Distribution: {params['init_state_name']}")
+    log_to_console(f"  Velocity: vx={params['vx_expr']}, vy={params['vy_expr']}, vz={params['vz_expr']}")
+    
+    if progress_callback:
+        progress_callback(5)
+    
+    # Create initial state circuit using qlbm_sample_app function
+    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"],
+    )
+    
+    if progress_callback:
+        progress_callback(15)
+    
+    log_to_console("Running Qiskit Aer statevector simulation...")
+    log_to_console(f"  Processing {len(params['T_list'])} timestep(s)...")
+    
+    # Determine velocity resolution (cap for performance)
+    vel_resolution = min(params['grid_size'], 32)
+    
+    # Run simulation using qlbm_sample_app function
+    output, fig = run_sampling_sim(
+        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"],
+        vel_resolution=vel_resolution,
+    )
+    
+    if progress_callback:
+        progress_callback(95)
+    
+    log_to_console(f"Simulation complete: {len(output)} frame(s) generated")
+    
+    return output, fig, params["T_list"]
+
+
 # --- Main Simulation ---
 def run_simulation():
     """Run the QLBM simulation."""
@@ -826,19 +983,33 @@ def run_simulation():
     _state.qlbm_is_running = True
     _state.qlbm_run_error = ""
     _state.qlbm_simulation_has_run = False
+    _state.qlbm_qiskit_mode = False  # Reset Qiskit mode
     _state.qlbm_show_progress = True
     _state.qlbm_simulation_progress = 0
     _state.qlbm_status_message = "Running simulation..."
     _state.qlbm_status_type = "info"
     
+    # Determine if using Qiskit backend
+    use_qiskit = (
+        _state.qlbm_backend_type == "Simulator" and 
+        _state.qlbm_selected_simulator == "IBM Qiskit simulator" and
+        _QISKIT_BACKEND_AVAILABLE
+    )
+    
     # Log initial configuration
+    backend_info = f"{_state.qlbm_backend_type}"
+    if _state.qlbm_backend_type == "Simulator":
+        backend_info += f" - {_state.qlbm_selected_simulator}"
+    elif _state.qlbm_backend_type == "QPU":
+        backend_info += f" - {_state.qlbm_selected_qpu}"
+    
     config_lines = [
         "Job Initiated",
         f"  Grid Size: {_state.qlbm_grid_size} × {_state.qlbm_grid_size} × {_state.qlbm_grid_size}",
         f"  Time Steps: {_state.qlbm_time_steps}",
         f"  Distribution: {_state.qlbm_dist_type}",
         f"  Boundary: {_state.qlbm_boundary_condition}",
-        f"  Backend: {_state.qlbm_backend_type}",
+        f"  Backend: {backend_info}",
         f"  Velocity: vx={_state.qlbm_vx_expr}, vy={_state.qlbm_vy_expr}, vz={_state.qlbm_vz_expr}",
     ]
     for line in config_lines:
@@ -853,84 +1024,116 @@ def run_simulation():
             last_logged_percent = percent
     
     try:
-        grid_size = int(_state.qlbm_grid_size)
-        num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
-        T = int(_state.qlbm_time_steps)
-        distribution_type = _state.qlbm_dist_type
-        boundary_condition = _state.qlbm_boundary_condition
-        
-        vx_func = make_velocity_func(_state.qlbm_vx_expr)
-        vy_func = make_velocity_func(_state.qlbm_vy_expr)
-        vz_func = make_velocity_func(_state.qlbm_vz_expr)
-        
-        _progress_callback(0)
-        
-        if simulate_qlbm_3D_and_animate is not None:
-            log_to_console("Running CUDA-Q Simulation...")
-            _plotter.clear()
-            _, frames, times, grid_obj = simulate_qlbm_3D_and_animate(
-                num_reg_qubits=num_reg_qubits,
-                T=T,
-                distribution_type=distribution_type,
-                vx_input=vx_func,
-                vy_input=vy_func,
-                vz_input=vz_func,
-                boundary_condition=boundary_condition,
-                plotter=_plotter,
-                add_slider=False,
-                progress_callback=_progress_callback
-            )
-        else:
-            log_to_console("Running CPU Demo Simulation...")
-            frames, times, grid_obj = _run_cpu_demo_simulation(
-                grid_size=grid_size,
-                T=T,
-                distribution_type=distribution_type or "Sinusoidal",
-                vx_func=vx_func,
-                vy_func=vy_func,
-                vz_func=vz_func,
-                progress_callback=_progress_callback
-            )
-        
-        _progress_callback(100)
-        
-        # Update plotter with results
-        if grid_obj:
-            _plotter.clear()
-            isosurfaces = grid_obj.contour(isosurfaces=7, scalars="scalars")
-            _plotter.add_mesh(isosurfaces, cmap="Blues", opacity=0.3, show_scalar_bar=True)
-            _plotter.add_axes()
-            _plotter.show_grid()
-        
-        # Store Results
-        if frames and len(frames) > 0:
-            simulation_data_frames = frames
-            simulation_times = times
-            current_grid_object = grid_obj
+        # === Qiskit Backend (IBM Qiskit Simulator) ===
+        if use_qiskit:
+            log_to_console("Using IBM Qiskit Simulator backend...")
+            
+            # Run Qiskit simulation
+            output, plotly_fig, T_list = _run_qiskit_simulation(progress_callback=_progress_callback)
+            
+            # Store results
+            simulation_data_frames = output
+            simulation_times = [float(t) for t in T_list]
+            
+            # Update the Plotly figure widget for Qiskit results
+            if hasattr(_ctrl, "qlbm_qiskit_result_update"):
+                _ctrl.qlbm_qiskit_result_update(plotly_fig)
             
-            _state.qlbm_max_time_step = len(frames) - 1
+            _state.qlbm_max_time_step = len(output) - 1
             _state.qlbm_time_val = 0
-            _state.qlbm_time_slider_labels = [f"{t:.1f}" for t in times] if times else [str(i) for i in range(len(frames))]
+            _state.qlbm_time_slider_labels = [f"T={t}" for t in T_list]
             _state.qlbm_simulation_has_run = True
+            _state.qlbm_qiskit_mode = True  # Use Plotly display instead of PyVista
             
-            _ensure_point_picking(on_pick_point)
-            
-            if hasattr(_ctrl, "qlbm_view_update"):
-                _ctrl.qlbm_view_update()
-            log_to_console("Simulation completed successfully.")
+            _progress_callback(100)
+            log_to_console("Qiskit simulation completed successfully.")
             _state.qlbm_status_message = "Simulation completed successfully."
             _state.qlbm_status_type = "success"
-            _state.qlbm_simulation_progress = 100
+        
+        # === CUDA-Q or CPU Demo Backend ===
         else:
-            _state.qlbm_run_error = "Simulation produced no data."
-            log_to_console("Error: Simulation produced no data.")
-            _state.qlbm_status_message = "Error: No data produced"
-            _state.qlbm_status_type = "error"
+            _state.qlbm_qiskit_mode = False  # Use PyVista display
+            
+            grid_size = int(_state.qlbm_grid_size)
+            num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
+            T = int(_state.qlbm_time_steps)
+            distribution_type = _state.qlbm_dist_type
+            boundary_condition = _state.qlbm_boundary_condition
+            
+            vx_func = make_velocity_func(_state.qlbm_vx_expr)
+            vy_func = make_velocity_func(_state.qlbm_vy_expr)
+            vz_func = make_velocity_func(_state.qlbm_vz_expr)
+            
+            _progress_callback(0)
+            
+            if simulate_qlbm_3D_and_animate is not None:
+                log_to_console("Running CUDA-Q Simulation...")
+                _plotter.clear()
+                _, frames, times, grid_obj = simulate_qlbm_3D_and_animate(
+                    num_reg_qubits=num_reg_qubits,
+                    T=T,
+                    distribution_type=distribution_type,
+                    vx_input=vx_func,
+                    vy_input=vy_func,
+                    vz_input=vz_func,
+                    boundary_condition=boundary_condition,
+                    plotter=_plotter,
+                    add_slider=False,
+                    progress_callback=_progress_callback
+                )
+            else:
+                log_to_console("Running CPU Demo Simulation...")
+                frames, times, grid_obj = _run_cpu_demo_simulation(
+                    grid_size=grid_size,
+                    T=T,
+                    distribution_type=distribution_type or "Sinusoidal",
+                    vx_func=vx_func,
+                    vy_func=vy_func,
+                    vz_func=vz_func,
+                    progress_callback=_progress_callback
+                )
+            
+            _progress_callback(100)
+            
+            # Update plotter with results
+            if grid_obj:
+                _plotter.clear()
+                isosurfaces = grid_obj.contour(isosurfaces=7, scalars="scalars")
+                _plotter.add_mesh(isosurfaces, cmap="Blues", opacity=0.3, show_scalar_bar=True)
+                _plotter.add_axes()
+                _plotter.show_grid()
+            
+            # Store Results
+            if frames and len(frames) > 0:
+                simulation_data_frames = frames
+                simulation_times = times
+                current_grid_object = grid_obj
+                
+                _state.qlbm_max_time_step = len(frames) - 1
+                _state.qlbm_time_val = 0
+                _state.qlbm_time_slider_labels = [f"{t:.1f}" for t in times] if times else [str(i) for i in range(len(frames))]
+                _state.qlbm_simulation_has_run = True
+                
+                _ensure_point_picking(on_pick_point)
+                
+                if hasattr(_ctrl, "qlbm_view_update"):
+                    _ctrl.qlbm_view_update()
+                log_to_console("Simulation completed successfully.")
+                _state.qlbm_status_message = "Simulation completed successfully."
+                _state.qlbm_status_type = "success"
+                _state.qlbm_simulation_progress = 100
+            else:
+                _state.qlbm_run_error = "Simulation produced no data."
+                log_to_console("Error: Simulation produced no data.")
+                _state.qlbm_status_message = "Error: No data produced"
+                _state.qlbm_status_type = "error"
 
     except Exception as e:
         _state.qlbm_run_error = f"Simulation failed: {str(e)}"
         log_to_console(f"Simulation Error: {e}")
         print(f"Simulation Error: {e}")
+        import traceback
+        traceback.print_exc()
         _state.qlbm_status_message = "Simulation failed"
         _state.qlbm_status_type = "error"
     finally:
@@ -955,6 +1158,7 @@ def reset_simulation():
     _state.qlbm_is_running = False
     _state.qlbm_run_error = ""
     _state.qlbm_simulation_has_run = False
+    _state.qlbm_qiskit_mode = False  # Reset Qiskit mode
     _state.qlbm_dist_type = None
     _state.qlbm_show_edges = False
     _state.qlbm_problems_selection = None
@@ -1263,7 +1467,7 @@ def _build_control_panels(plotter):
     with vuetify3.VCard(classes="mb-2"):
         vuetify3.VCardTitle("Time", classes="text-subtitle-2 font-weight-bold text-primary")
         with vuetify3.VCardText():
-            vuetify3.VSlider(label="Total Time", v_model=("qlbm_time_steps", 10), min=0, max=2000, step=10, 
+            vuetify3.VSlider(label="Total Time", v_model=("qlbm_time_steps", 10), min=0, max=50, step=2, 
                            thumb_label="always", show_ticks="always", color="primary", density="compact", hide_details=True)
             vuetify3.VAlert(v_if="qlbm_time_steps > 100", type="warning", variant="tonal", density="compact", 
                            children=["Warning: High time steps may increase runtime."], classes="mt-2")
@@ -1357,19 +1561,19 @@ def _build_visualization_panel(plotter):
     # Main Plot Card
     with vuetify3.VCard(classes="mb-1 flex-grow-1 d-flex flex-column", elevation=2, style="min-height: 0;"):
          
-         # Geometry Preview (Plotly)
+         # Geometry Preview (Plotly) - when no simulation and no distribution selected
          with vuetify3.VContainer(v_if="!qlbm_simulation_has_run && !qlbm_dist_type && qlbm_geometry_selection", 
                                   fluid=True, classes="pa-0 flex-grow-1", style="width: 100%; height: 100%;"):
             geom_fig = plotly_widgets.Figure(figure=go.Figure(), style="width: 100%; height: 100%;", responsive=True)
             _ctrl.qlbm_geometry_plot_update = geom_fig.update
 
-         # Distribution Preview (Plotly)
+         # Distribution Preview (Plotly) - when distribution selected but no simulation
          with vuetify3.VContainer(v_if="!qlbm_simulation_has_run && qlbm_dist_type", 
                                   fluid=True, classes="pa-0 flex-grow-1", style="width: 100%; height: 100%;"):
             preview_fig = plotly_widgets.Figure(figure=go.Figure(), style="width:100%; height:100%;", responsive=True)
             _ctrl.qlbm_preview_update = preview_fig.update
 
-         # Download controls
+         # Download controls (for both modes)
          with vuetify3.VContainer(v_if="qlbm_simulation_has_run", classes="px-4 pt-3 pb-1 d-flex justify-end", 
                                   style="width: 100%; flex: 0 0 auto;"):
              with vuetify3.VMenu(location="bottom end"):
@@ -1382,25 +1586,48 @@ def _build_visualization_panel(plotter):
                          prepend_icon="mdi-download"
                      )
                  with vuetify3.VList(density="compact"):
+                     # VTK and MP4 exports only for non-Qiskit mode
                      vuetify3.VListItem(
+                         v_if="!qlbm_qiskit_mode",
                          title="Export as VTK",
                          prepend_icon="mdi-content-save",
                          click=export_simulation_vtk
                      )
                      vuetify3.VListItem(
+                         v_if="!qlbm_qiskit_mode",
                          title="Export as MP4",
                          prepend_icon="mdi-movie",
                          click=export_simulation_mp4
                      )
+                     # TODO: Add Plotly HTML export for Qiskit mode
+                     vuetify3.VListItem(
+                         v_if="qlbm_qiskit_mode",
+                         title="Export as HTML (Plotly)",
+                         prepend_icon="mdi-language-html5",
+                         disabled=True,  # Not yet implemented
+                     )
+
+         # === Qiskit Simulation Result (Plotly with built-in slider) ===
+         with vuetify3.VContainer(v_if="qlbm_simulation_has_run && qlbm_qiskit_mode", 
+                                  fluid=True, classes="pa-0 flex-grow-1", 
+                                  style="width: 100%; height: 100%;"):
+            qiskit_fig = plotly_widgets.Figure(
+                figure=go.Figure(), 
+                style="width:100%; height:100%;", 
+                responsive=True
+            )
+            _ctrl.qlbm_qiskit_result_update = qiskit_fig.update
 
-         # Simulation Result (PyVista)
-         with vuetify3.VContainer(v_if="qlbm_simulation_has_run", fluid=True, classes="pa-0 flex-grow-1", 
+         # === PyVista Simulation Result (for CUDA-Q/CPU demo) ===
+         with vuetify3.VContainer(v_if="qlbm_simulation_has_run && !qlbm_qiskit_mode", 
+                                  fluid=True, classes="pa-0 flex-grow-1", 
                                   style="width: 100%; height: 100%;"):
             view = plotter_ui(plotter)
             _ctrl.qlbm_view_update = view.update
          
-         # Time Slider
-         with vuetify3.VContainer(v_if="qlbm_simulation_has_run", classes="px-4 pb-4", style="width: 90%; flex: 0 0 auto;"):
+         # Time Slider (only for non-Qiskit mode - Qiskit Plotly has built-in slider)
+         with vuetify3.VContainer(v_if="qlbm_simulation_has_run && !qlbm_qiskit_mode", 
+                                  classes="px-4 pb-4", style="width: 90%; flex: 0 0 auto;"):
              with vuetify3.VSlider(
                  v_model=("qlbm_time_val", 0),
                  min=0,

requirements.txt

@@ -1,6 +1,6 @@
 # Core scientific computing
 numpy==2.2.6
-scipy==1.16.2
+scipy==1.15.3
 cudaq 
 
 # 3D Visualization