update qlbm_sample_app.py to include the T=0 snapshot in the hardware results (saving QPU costs by computing the initial state locally) and modify qlbm_embedded.py to integrate the IonQ backend

qlbm/qlbm_sample_app.py

@@ -130,15 +130,15 @@ def get_coeffs(n,ux,uy,uz,resolution=32):
   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))
+                          ((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))
+                          ((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))
+                          ((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))
+                          (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))
+                          ((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_,\
@@ -577,17 +577,29 @@ def run_sampling_hw_ibm(
   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...")
+  # job = sampler.run(qc_compiled_list, shots=shots)
+  # log("Job submitted; waiting for result...")
 
   def get_job_result(j):
     result = j.result()   # PrimitiveResult (a container of PubResults)
     log("Waiting for job results (this may take time)...")
 
+    # --- NEW: Calculate T=0 snapshot locally ---
+    initial_snapshot = None
+    try:
+        initial_snapshot = show_initial_distribution(
+            n=n,
+            init_state_circuit=init_state_prep_circ,
+            plot=False,
+            return_data=True
+        )
+    except Exception as e:
+        log(f"Warning: Could not compute T=0 snapshot: {e}")
+    # -------------------------------------------
+
     output=[]
 
     for T_total,pub in zip(T_list,result):
-
       # Try join_data() to combine multiple regs and get_counts() on it
       try:
           joined = pub.join_data()    # join_data concatenates registers along bits axis
@@ -601,7 +613,18 @@ def run_sampling_hw_ibm(
       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)
+
+    # --- NEW: Prepend T=0 to output ---
+    plot_T_list = list(T_list)
+    if initial_snapshot is not None:
+        initial_density, _ = initial_snapshot
+        # Only prepend if T=0 isn't already in the list
+        if not (plot_T_list and plot_T_list[0] == 0):
+            output.insert(0, initial_density)
+            plot_T_list.insert(0, 0)
+    # ----------------------------------
+
+    fig = plot_density_isosurface_slider(output, plot_T_list)
     return output, fig
   
   return job,get_job_result
@@ -659,34 +682,31 @@ def run_sampling_hw_ionq(
       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)...")
 
+    # --- NEW: Calculate T=0 snapshot locally ---
+    initial_snapshot = None
+    try:
+        initial_snapshot = show_initial_distribution(
+            n=n,
+            init_state_circuit=init_state_prep_circ,
+            plot=False,
+            return_data=True
+        )
+    except Exception as e:
+        log(f"Warning: Could not compute T=0 snapshot: {e}")
+    # -------------------------------------------
+
     output=[]
 
     for i,T_total in enumerate(T_list):
@@ -698,7 +718,17 @@ def run_sampling_hw_ionq(
       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)
+
+    # --- NEW: Prepend T=0 to output ---
+    plot_T_list = list(T_list)
+    if initial_snapshot is not None:
+        initial_density, _ = initial_snapshot
+        if not (plot_T_list and plot_T_list[0] == 0):
+            output.insert(0, initial_density)
+            plot_T_list.insert(0, 0)
+    # ----------------------------------
+
+    fig = plot_density_isosurface_slider(output, plot_T_list)
     return output, fig
   
   return job,get_job_result
@@ -778,7 +808,7 @@ def run_sampling_sim(
       result = job.result()
       data_all = result.data()
       
-      statevector_keys = list(dict(data_all['statevector']).keys())
+      statevector_keys = list(dict(data_all['statevector']).keys());
       
       # Look for the zero branch (0x0)
       zero_key = None

qlbm_embedded.py

@@ -30,6 +30,7 @@ try:
     from qlbm.qlbm_sample_app import (
         run_sampling_sim,
         run_sampling_hw_ibm,
+        run_sampling_hw_ionq,  # <--- Added import
         get_named_init_state_circuit,
         str_to_lambda,
         _create_slider_figure,
@@ -1105,6 +1106,13 @@ def run_simulation():
         _state.qlbm_selected_qpu == "IBM QPU" and
         _QISKIT_BACKEND_AVAILABLE
     )
+    # --- NEW: IonQ Detection ---
+    use_ionq_qpu = (
+        _state.qlbm_backend_type == "QPU" and 
+        _state.qlbm_selected_qpu == "IonQ QPU" and
+        _QISKIT_BACKEND_AVAILABLE
+    )
+    # ---------------------------
     
     # Log initial configuration
     backend_info = f"{_state.qlbm_backend_type}"
@@ -1200,9 +1208,12 @@ def run_simulation():
             if hasattr(_ctrl, "qlbm_qiskit_result_update"):
                 _ctrl.qlbm_qiskit_result_update(plotly_fig)
             
+            # Update slider labels (include T=0 if present)
+            final_T_list = [0] + params["T_list"] if len(output) > len(params["T_list"]) else params["T_list"]
+            
             _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_time_slider_labels = [f"T={t}" for t in final_T_list]
             _state.qlbm_simulation_has_run = True
             _state.qlbm_qiskit_mode = True
             
@@ -1211,6 +1222,68 @@ def run_simulation():
             _state.qlbm_status_message = "Simulation completed successfully."
             _state.qlbm_status_type = "success"
         
+        # === NEW: IonQ QPU Backend ===
+        elif use_ionq_qpu:
+            log_to_console("Using IonQ 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"],
+                mdd_kx_log2=params["mdd_kx_log2"],
+                mdd_ky_log2=params["mdd_ky_log2"],
+                mdd_kz_log2=params["mdd_kz_log2"],
+            )
+
+            log_to_console("Submitting job to IonQ...")
+            
+            # Run HW simulation
+            job, get_result = run_sampling_hw_ionq(
+                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**18,
+                vel_resolution=min(params['grid_size'], 32),
+                output_resolution=min(2*params['grid_size'], 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)
+            
+            # Update slider labels (include T=0 if present)
+            final_T_list = [0] + params["T_list"] if len(output) > len(params["T_list"]) else params["T_list"]
+            
+            _state.qlbm_max_time_step = len(output) - 1
+            _state.qlbm_time_val = 0
+            _state.qlbm_time_slider_labels = [f"T={t}" for t in final_T_list]
+            _state.qlbm_simulation_has_run = True
+            _state.qlbm_qiskit_mode = True
+            
+            _progress_callback(100)
+            log_to_console("IonQ 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":
             _state.qlbm_qiskit_mode = False  # Use PyVista display
@@ -1725,7 +1798,13 @@ def _build_control_panels(plotter):
                     )
             with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end"):
                 with vuetify3.Template(v_slot_activator="{ props }"):
-                    vuetify3.VBtn(v_bind="props", text="Choose Backend", color="primary", variant="tonal", block=True)
+                    vuetify3.VBtn(
+                        v_bind="props",
+                        text="Choose Backend",
+                        color="primary",
+                        variant="tonal",
+                        block=True
+                    )
                 with vuetify3.VList(density="compact"):
                     with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
                         with vuetify3.Template(v_slot_activator="{ props }"):