Enforce snap to grid behavior for both Delta and Gaussian excitations in the simulator, matching QPU semantics.

em/simulation.py

@@ -215,7 +215,7 @@ def redraw_surface_plot():
         mesh,
         scalars='scalars',
         # clim=g.surface_clims[field],
-        cmap="Blues",
+        cmap="turbo",
         show_scalar_bar=False,
         show_edges=True,
         edge_color='grey',
@@ -307,13 +307,15 @@ def run_simulation_only():
         if state.dist_type == "Delta":
             initial_state = create_impulse_state_from_pos(
                 (nx, nx), 
-                (float(state.impulse_x), float(state.impulse_y))
+                (float(state.impulse_x), float(state.impulse_y)),
+                snap_to_grid=True,
             )
         else:
             initial_state = create_gaussian_state_from_pos(
                 (nx, nx), 
                 (float(state.mu_x), float(state.mu_y)), 
-                (float(state.sigma_x), float(state.sigma_y))
+                (float(state.sigma_x), float(state.sigma_y)),
+                snap_to_grid=True,
             )
     except ValueError as e:
         state.error_message = f"Initial State Error: {e}"

qlbm/qlbm_sample_app.py

@@ -509,7 +509,7 @@ def run_sampling_hw_ibm(
     uz,
     init_state_prep_circ,
     T_list,
-    shots=2**19,
+    shots=2**14,
     vel_resolution=32,
     output_resolution=40,
     logger=None,
@@ -619,7 +619,7 @@ def run_sampling_hw_ionq(
     uz,
     init_state_prep_circ,
     T_list,
-    shots=2**19,
+    shots=2**14,
     vel_resolution=32,
     output_resolution=40,
     logger=None,

qlbm_embedded.py

@@ -1197,7 +1197,7 @@ def run_simulation():
                 init_state_prep_circ=init_state_prep_circ,
                 T_list=params["T_list"],
                 # shots=2**14, # Reduced shots for responsiveness/quota
-                shots=2**18,
+                shots=2**14,
                 vel_resolution=min(params['grid_size'], 32),
                 output_resolution=min(2*params['grid_size'], 40),
                 logger=log_to_console
@@ -1290,7 +1290,7 @@ def run_simulation():
                 uz=params["vz_expr"],
                 init_state_prep_circ=init_state_prep_circ,
                 T_list=params["T_list"],
-                shots=2**18,
+                shots=2**14,
                 vel_resolution=min(params['grid_size'], 32),
                 output_resolution=min(2*params['grid_size'], 40),
                 logger=log_to_console
@@ -1398,7 +1398,7 @@ def run_simulation():
             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_mesh(isosurfaces, cmap="turbo", opacity=0.3, show_scalar_bar=True)
                 _plotter.add_axes()
                 _plotter.show_grid()
             
@@ -1837,7 +1837,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=50, step=2, 
+            vuetify3.VSlider(label="Total Time", v_model=("qlbm_time_steps", 10), min=0, max=30, step=1, 
                            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")

utils/delta_impulse_generator.py

@@ -107,16 +107,31 @@ def _normalize_to_unit(vec: np.ndarray) -> np.ndarray:
 
 
 
-def create_impulse_state_from_pos(grid_dims, pos01):
+def create_impulse_state_from_pos(grid_dims, pos01, snap_to_grid=True):
     """
     Create a delta-like initial state from continuous position pos01=(x,y) in [0,1].
 
+    Args:
+        grid_dims: Tuple (nx, ny) defining the simulation grid dimensions.
+        pos01: Tuple (x, y) with continuous position in [0, 1] range.
+        snap_to_grid: If True (default), snaps the impulse to the nearest grid node
+                      for an exact delta with peak value = 1.0. If False, uses
+                      bilinear interpolation which distributes amplitude to 4 nodes.
+
     Why grid_dims?
     - Simulation runs on a discrete nx×ny lattice; the continuous position must be
       discretized onto that grid to produce the state vector fed into the solver.
-    - grid_dims provides (nx, ny) so we can map (x,y)∈[0,1]→grid coordinates via
-      gx = x*(nx-1), gy = y*(ny-1), then distribute amplitude bilinearly to the 4
-      neighboring nodes. This is required only for the simulation state, not the preview.
+    - grid_dims provides (nx, ny) so we can map (x,y)∈[0,1]→grid coordinates.
+
+    When snap_to_grid=True (default):
+    - The impulse is placed exactly on the nearest grid node.
+    - Peak amplitude = 1.0 (exact delta function on the discrete grid).
+    - This is recommended for visualization and accurate peak value display.
+
+    When snap_to_grid=False:
+    - Uses bilinear interpolation to distribute amplitude to the 4 neighboring nodes.
+    - Peak amplitude depends on position (e.g., 0.5 when exactly between 4 nodes).
+    - Total energy is preserved (L2 norm = 1).
 
     The preview uses create_impulse_preview_state(), which renders a smooth bump on a
     fixed unit-square grid independent of nx for visualization.
@@ -128,6 +143,25 @@ def create_impulse_state_from_pos(grid_dims, pos01):
 
     gx = px * (grid_width - 1)
     gy = py * (grid_height - 1)
+
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+
+    if snap_to_grid:
+        # Snap to nearest grid node for exact delta with peak = 1.0
+        i0 = int(round(gx))
+        j0 = int(round(gy))
+        i0 = max(0, min(i0, grid_width - 1))
+        j0 = max(0, min(j0, grid_height - 1))
+
+        field = np.zeros(grid_size)
+        field[j0 * grid_width + i0] = 1.0  # Peak value = 1.0
+
+        initial_state = np.zeros(total_size)
+        initial_state[:grid_size] = field
+        return initial_state
+
+    # Bilinear interpolation mode (snap_to_grid=False)
     i0, j0 = int(np.floor(gx)), int(np.floor(gy))
     i1, j1 = min(i0 + 1, grid_width - 1), min(j0 + 1, grid_height - 1)
     dx, dy = gx - i0, gy - j0
@@ -137,8 +171,6 @@ def create_impulse_state_from_pos(grid_dims, pos01):
     w01 = (1 - dx) * dy
     w11 = dx * dy
 
-    grid_size = grid_width * grid_height
-    total_size = 4 * grid_size
     field = np.zeros(grid_size)
     field[j0 * grid_width + i0] += w00
     field[j0 * grid_width + i1] += w10
@@ -151,11 +183,19 @@ def create_impulse_state_from_pos(grid_dims, pos01):
     return initial_state
 
 
-def create_gaussian_state_from_pos(grid_dims, mu01, sigma01):
+def create_gaussian_state_from_pos(grid_dims, mu01, sigma01, snap_to_grid=True):
     """
     Create a Gaussian initial state with center mu01=(x,y) and spreads sigma01=(sx,sy)
     in [0,1] of the domain, then discretize to the solver grid given by grid_dims.
 
+    Args:
+        grid_dims: Tuple (nx, ny) defining the simulation grid dimensions.
+        mu01: Tuple (x, y) with Gaussian center in [0, 1].
+        sigma01: Tuple (sx, sy) with Gaussian std dev as fraction of domain in [0, 1].
+        snap_to_grid: If True (default), snap the Gaussian center to the nearest grid
+            node before discretization. This makes the simulator behavior consistent
+            with the "nearest-node" semantics often used elsewhere in the app.
+
     Why grid_dims?
     - The quantum solver expects a vector aligned to the chosen nx×ny simulation grid.
       We convert normalized μ and σ (fractions of the domain) into grid units using
@@ -177,6 +217,11 @@ def create_gaussian_state_from_pos(grid_dims, mu01, sigma01):
 
     mu_x = mu_x01 * (grid_width - 1)
     mu_y = mu_y01 * (grid_height - 1)
+    if snap_to_grid:
+        mu_x = float(int(round(mu_x)))
+        mu_y = float(int(round(mu_y)))
+        mu_x = float(max(0, min(int(mu_x), grid_width - 1)))
+        mu_y = float(max(0, min(int(mu_y), grid_height - 1)))
     sigma_x = sig_x01 * (grid_width - 1)
     sigma_y = sig_y01 * (grid_height - 1)