QLBM IONQ Upload Window, refined

qlbm/visualize_counts.py

@@ -34,6 +34,10 @@ def load_samples(d, T_total, logger=None, flag_qubits=False, midcircuit_meas=Tru
       Total number of timesteps (used to determine how many direction bits to check)
   logger : callable, optional
       Function to log messages
+  flag_qubits : bool
+      Whether flag qubits were used in the circuit
+  midcircuit_meas : bool
+      Whether mid-circuit measurement was used (IBM uses True, IonQ uses False)
   
   Returns
   -------
@@ -64,16 +68,130 @@ def load_samples(d, T_total, logger=None, flag_qubits=False, midcircuit_meas=Tru
     log("Warning: Empty counts dictionary")
     return np.array(pts), np.array(counts)
   
-  # Debug: show sample bitstrings
+  # Detect format: IonQ returns decimal strings, IBM returns binary strings
+  # Also detect hex format and UUID-like keys (which indicate wrong data structure)
   sample_keys = list(d.keys())[:3]
+  
+  # Check if keys look like UUIDs (job IDs) - this indicates wrong JSON structure
+  is_uuid_format = False
+  if sample_keys:
+    first_key = str(sample_keys[0])
+    # UUID pattern: contains hyphens and hex chars, length ~36
+    if '-' in first_key and len(first_key) > 30:
+      is_uuid_format = True
+      log(f"ERROR: Keys appear to be UUIDs/job IDs, not measurement bitstrings!")
+      log(f"This suggests the JSON file structure is not being parsed correctly.")
+      log(f"Expected: measurement outcomes like '0', '1', '101010', '0x1a2b'")
+      log(f"Got: {first_key}")
+      return np.array([]), np.array([])
+  
+  # Check for hex format (IonQ sometimes returns hex like '0x1a2b' or just 'a1b2')
+  is_hex_format = False
+  if sample_keys and not is_uuid_format:
+    first_key = str(sample_keys[0]).replace(" ", "").lower()
+    # Check if it's hex (contains a-f and/or starts with 0x)
+    if first_key.startswith('0x'):
+      is_hex_format = True
+    elif any(c in 'abcdef' for c in first_key) and all(c in '0123456789abcdef' for c in first_key):
+      is_hex_format = True
+  
+  # Check if keys look like decimal integers (short strings of digits only)
+  is_decimal_format = False
+  if sample_keys and not is_uuid_format and not is_hex_format:
+    first_key = str(sample_keys[0]).replace(" ", "")
+    # If the key is short and all digits, it's likely decimal format (IonQ)
+    # Binary strings from IBM are much longer and only contain 0s and 1s
+    if first_key.isdigit() and len(first_key) < 20:
+      # Additional check: if any key has digits other than 0 and 1, it's decimal
+      for key in sample_keys:
+        key_str = str(key).replace(" ", "")
+        if any(c not in '01' for c in key_str):
+          is_decimal_format = True
+          break
+      # Also check if length is suspiciously short for expected binary
+      if not is_decimal_format and len(first_key) < pref_length // 2:
+        is_decimal_format = True
+  
+  # Compute total_bits for decimal or hex format
+  total_bits = pref_length + 9  # default minimum
+  
+  if is_hex_format:
+    log(f"Detected hex format, converting to binary...")
+    # Find max value to determine bit width
+    max_val = 0
+    for k in d.keys():
+      k_str = str(k).replace(" ", "").lower()
+      if k_str.startswith('0x'):
+        k_str = k_str[2:]
+      try:
+        val = int(k_str, 16)
+        max_val = max(max_val, val)
+      except ValueError:
+        pass
+    total_bits = max(max_val.bit_length(), pref_length + 9)
+    log(f"Max value: {max_val}, using {total_bits} total bits")
+  elif is_decimal_format:
+    log(f"Detected IonQ decimal format, converting to binary...")
+    # Determine total bit width needed
+    # For IonQ without mid-circuit measurement: 6*(T_total+1) prefix + 3*n position bits
+    # We need to figure out n from the maximum value in keys
+    max_val = max(int(str(k).replace(" ", "")) for k in d.keys())
+    total_bits = max_val.bit_length()
+    # Round up to ensure we have enough bits
+    total_bits = max(total_bits, pref_length + 9)  # At least 3 qubits per dimension
+    log(f"Max value: {max_val}, using {total_bits} total bits")
+  
+  # Debug: show sample bitstrings
   log(f"Sample bitstrings (first 3): {sample_keys}")
   if sample_keys:
-    log(f"Bitstring length: {len(sample_keys[0])}")
+    if is_hex_format:
+      # Show what they look like after conversion
+      converted = []
+      for k in sample_keys[:3]:
+        k_str = str(k).replace(" ", "").lower()
+        if k_str.startswith('0x'):
+          k_str = k_str[2:]
+        try:
+          converted.append(bin(int(k_str, 16))[2:].zfill(total_bits))
+        except ValueError:
+          converted.append(f"<invalid:{k}>")
+      log(f"Converted from hex to binary (first 3): {converted}")
+      log(f"Binary length: {len(converted[0]) if converted else 0}")
+    elif is_decimal_format:
+      # Show what they look like after conversion
+      converted = [bin(int(str(k).replace(" ", "")))[2:].zfill(total_bits) for k in sample_keys[:3]]
+      log(f"Converted to binary (first 3): {converted}")
+      log(f"Binary length: {len(converted[0]) if converted else 0}")
+    else:
+      log(f"Bitstring length: {len(str(sample_keys[0]).replace(' ', ''))}")
     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
-    bs=bs.replace(" ","")
+  for bs_raw, cnt in d.items():
+    # Convert to binary string
+    bs_raw_str = str(bs_raw).replace(" ", "")
+    
+    if is_hex_format:
+      # Convert hex to binary with proper padding
+      hex_str = bs_raw_str.lower()
+      if hex_str.startswith('0x'):
+        hex_str = hex_str[2:]
+      try:
+        decimal_val = int(hex_str, 16)
+        bs = bin(decimal_val)[2:].zfill(total_bits)
+      except ValueError:
+        continue  # Skip invalid hex
+    elif is_decimal_format:
+      # Convert decimal to binary with proper padding
+      decimal_val = int(bs_raw_str)
+      bs = bin(decimal_val)[2:].zfill(total_bits)
+    else:
+      bs = bs_raw_str
+    
+    # Check if the direction qubits (first pref_length bits) are all zeros
+    if len(bs) < pref_length:
+      # Pad with leading zeros if needed
+      bs = bs.zfill(pref_length + 9)  # Ensure at least 3 qubits per dimension
+    
     prefix = bs[:pref_length]
     expected_prefix = "0" * pref_length
     
@@ -83,8 +201,12 @@ def load_samples(d, T_total, logger=None, flag_qubits=False, midcircuit_meas=Tru
       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")
-          continue
+          # Try to pad to make divisible by 3
+          pad_needed = (3 - len(remaining_bits) % 3) % 3
+          remaining_bits = "0" * pad_needed + remaining_bits
+          if len(remaining_bits) % 3 != 0:
+              log(f"Warning: Remaining bitstring length {len(remaining_bits)} not divisible by 3")
+              continue
       x, y, z = bitstring_to_xyz(remaining_bits)
       pts.append([x, y, z])
       counts.append(cnt)

qlbm_embedded.py

@@ -1306,7 +1306,17 @@ def process_uploaded_job_result():
             # IBM PrimitiveResult structure: result is a list of PubResults
             # Each PubResult has .join_data().get_counts()
             if hasattr(result, '__iter__') and not isinstance(result, dict):
-                for i, (T_total, pub) in enumerate(zip(T_list, result)):
+                result_list = list(result)
+                available_timesteps = len(result_list)
+                
+                # Validate timestep count
+                if len(T_list) > available_timesteps:
+                    log_to_console(f"Warning: Requested {len(T_list)} timesteps but result contains only {available_timesteps}")
+                    _state.qlbm_job_upload_error = f"Requested {len(T_list)} timesteps but result contains only {available_timesteps}. Please reduce Total Time T."
+                    _state.qlbm_job_is_processing = False
+                    return
+                
+                for i, (T_total, pub) in enumerate(zip(T_list, result_list)):
                     try:
                         # Try the PrimitiveResult API
                         if hasattr(pub, 'join_data'):
@@ -1338,7 +1348,129 @@ def process_uploaded_job_result():
                                              flag_qubits=flag_qubits, midcircuit_meas=midcircuit_meas)
                     output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
         else:
-            # IonQ result structure: use get_counts(i) or direct counts dict
+            # IonQ result structure - needs careful parsing
+            # IonQ saves results as: {"job_id_1": {"decimal_int": probability, ...}, "job_id_2": {...}, ...}
+            # Where:
+            #   - Top-level keys are job IDs (UUIDs like "06945432-f399-796d-8000-...")
+            #   - Each job represents one timestep/circuit
+            #   - Values are dicts with decimal integer keys (measurement outcomes) 
+            #   - Values in those dicts are probabilities (floats 0-1), NOT raw counts
+            
+            def is_uuid_like(s):
+                """Check if string looks like a UUID (contains hyphens, long)."""
+                return isinstance(s, str) and '-' in s and len(s) > 30
+            
+            def is_counts_dict(d):
+                """Check if dict looks like a counts/probabilities dict (numeric string keys)."""
+                if not isinstance(d, dict) or len(d) == 0:
+                    return False
+                sample_keys = list(d.keys())[:5]
+                # Keys should be numeric strings (decimal integers)
+                looks_like_counts = all(
+                    k.replace(' ', '').isdigit() or 
+                    (k.replace(' ', '').startswith('-') and k.replace(' ', '')[1:].isdigit())
+                    for k in sample_keys
+                )
+                if not looks_like_counts:
+                    return False
+                # Values should be numeric (int counts or float probabilities)
+                sample_vals = [d[k] for k in sample_keys]
+                return all(isinstance(v, (int, float)) for v in sample_vals)
+            
+            def probabilities_to_counts(prob_dict, num_shots=16384):
+                """Convert probability dict to counts dict by multiplying by num_shots."""
+                # Check if values are already counts (integers or floats > 1)
+                sample_vals = list(prob_dict.values())[:10]
+                max_val = max(sample_vals) if sample_vals else 0
+                
+                if max_val > 1:
+                    # Already counts (int or float > 1)
+                    return {k: int(v) for k, v in prob_dict.items()}
+                else:
+                    # Probabilities (0-1), convert to counts
+                    return {k: int(v * num_shots) for k, v in prob_dict.items() if int(v * num_shots) > 0}
+            
+            def extract_ionq_counts_from_job_ids(data, num_shots=16384):
+                """
+                Extract counts dicts from IonQ format where top-level keys are job IDs.
+                Returns list of counts dicts, one per job/timestep.
+                """
+                if not isinstance(data, dict):
+                    return None
+                
+                # Check if top-level keys are job IDs (UUIDs)
+                top_keys = list(data.keys())
+                if not top_keys:
+                    return None
+                
+                # If all/most keys are UUID-like, this is the job ID format
+                uuid_keys = [k for k in top_keys if is_uuid_like(k)]
+                if len(uuid_keys) == len(top_keys):
+                    # All keys are job IDs - extract counts from each
+                    counts_list = []
+                    for job_id in top_keys:
+                        job_data = data[job_id]
+                        if is_counts_dict(job_data):
+                            # Convert probabilities to counts
+                            counts = probabilities_to_counts(job_data, num_shots)
+                            counts_list.append(counts)
+                    return counts_list if counts_list else None
+                
+                return None
+            
+            def extract_ionq_counts(data):
+                """Recursively find a single counts dict in IonQ result structure."""
+                if not isinstance(data, dict):
+                    return None
+                
+                # Check if this is a counts dict directly
+                if is_counts_dict(data):
+                    return probabilities_to_counts(data)
+                
+                # Check for 'counts' key
+                if 'counts' in data:
+                    return extract_ionq_counts(data['counts'])
+                
+                # Check for 'data' key
+                if 'data' in data:
+                    return extract_ionq_counts(data['data'])
+                
+                # Check for 'results' key
+                if 'results' in data:
+                    return extract_ionq_counts(data['results'])
+                
+                return None
+            
+            def extract_ionq_counts_list(data):
+                """Extract list of counts dicts for multiple timesteps."""
+                if isinstance(data, list):
+                    counts_list = []
+                    for item in data:
+                        counts = extract_ionq_counts(item) if isinstance(item, dict) else item
+                        if counts:
+                            counts_list.append(counts)
+                    return counts_list if counts_list else None
+                return None
+            
+            # Debug: show top-level structure
+            if isinstance(result, dict):
+                top_keys = list(result.keys())[:5]
+                log_to_console(f"IonQ result top-level keys: {top_keys}")
+                uuid_count = sum(1 for k in result.keys() if is_uuid_like(k))
+                log_to_console(f"  UUID-like keys: {uuid_count}/{len(result)}")
+                for key in top_keys[:2]:
+                    val = result[key]
+                    if isinstance(val, dict):
+                        val_keys = list(val.keys())[:5]
+                        val_vals = [val[k] for k in val_keys]
+                        log_to_console(f"  '{key[:20]}...' contains dict with {len(val)} entries")
+                        log_to_console(f"    Sample keys: {val_keys}")
+                        log_to_console(f"    Sample values: {val_vals}")
+                    elif isinstance(val, list):
+                        log_to_console(f"  '{key}' is list with {len(val)} items")
+                    else:
+                        log_to_console(f"  '{key}' = {type(val).__name__}")
+            
             if hasattr(result, 'get_counts'):
                 for i, T_total in enumerate(T_list):
                     try:
@@ -1350,21 +1482,74 @@ def process_uploaded_job_result():
                     except Exception as e:
                         log_to_console(f"Error processing timestep {i}: {e}")
             elif isinstance(result, list):
-                # List of counts dicts
-                for i, (T_total, counts) in enumerate(zip(T_list, result)):
-                    if isinstance(counts, dict):
-                        log_to_console(f"Processing timestep T={T_total}")
+                # List of counts dicts - validate length
+                if len(T_list) > len(result):
+                    log_to_console(f"Warning: Requested {len(T_list)} timesteps but result contains only {len(result)}")
+                    _state.qlbm_job_upload_error = f"Requested {len(T_list)} timesteps but result contains only {len(result)}. Please reduce Total Time T."
+                    _state.qlbm_job_is_processing = False
+                    return
+                
+                for i, (T_total, item) in enumerate(zip(T_list, result)):
+                    counts = extract_ionq_counts(item) if isinstance(item, dict) else item
+                    if counts and isinstance(counts, dict):
+                        log_to_console(f"Processing timestep T={T_total}: {len(counts)} unique bitstrings")
                         pts, cnts = load_samples(counts, T_total, logger=log_to_console,
                                                  flag_qubits=flag_qubits, midcircuit_meas=False)
                         output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                    else:
+                        log_to_console(f"Could not extract counts for timestep T={T_total}")
             elif isinstance(result, dict):
-                # Single counts dict
-                counts = result.get('counts', result)
-                for T_total in T_list:
-                    log_to_console(f"Processing timestep T={T_total}")
-                    pts, cnts = load_samples(counts, T_total, logger=log_to_console,
-                                             flag_qubits=flag_qubits, midcircuit_meas=False)
-                    output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                # First: Try to detect IonQ format with job ID keys
+                job_id_counts_list = extract_ionq_counts_from_job_ids(result)
+                
+                if job_id_counts_list and len(job_id_counts_list) > 0:
+                    # IonQ job ID format - multiple jobs/timesteps
+                    log_to_console(f"Detected IonQ job ID format with {len(job_id_counts_list)} jobs")
+                    
+                    if len(T_list) > len(job_id_counts_list):
+                        log_to_console(f"Warning: Requested {len(T_list)} timesteps but result contains only {len(job_id_counts_list)} jobs")
+                        _state.qlbm_job_upload_error = f"Requested {len(T_list)} timesteps but result contains only {len(job_id_counts_list)} jobs. Please reduce Total Time T."
+                        _state.qlbm_job_is_processing = False
+                        return
+                    
+                    for i, (T_total, counts) in enumerate(zip(T_list, job_id_counts_list)):
+                        log_to_console(f"Processing timestep T={T_total}: {len(counts)} unique outcomes (converted from probabilities)")
+                        pts, cnts = load_samples(counts, T_total, logger=log_to_console,
+                                                 flag_qubits=flag_qubits, midcircuit_meas=False)
+                        output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                else:
+                    # Try to extract counts from nested structure
+                    counts = extract_ionq_counts(result)
+                    counts_list = extract_ionq_counts_list(result.get('results', result.get('data', [])))
+                    
+                    if counts_list and len(counts_list) > 0:
+                        # Multiple timesteps in result
+                        if len(T_list) > len(counts_list):
+                            log_to_console(f"Warning: Requested {len(T_list)} timesteps but result contains only {len(counts_list)}")
+                            _state.qlbm_job_upload_error = f"Requested {len(T_list)} timesteps but result contains only {len(counts_list)}. Please reduce Total Time T."
+                            _state.qlbm_job_is_processing = False
+                            return
+                        
+                        for i, (T_total, c) in enumerate(zip(T_list, counts_list)):
+                            log_to_console(f"Processing timestep T={T_total}: {len(c)} unique bitstrings")
+                            pts, cnts = load_samples(c, T_total, logger=log_to_console,
+                                                     flag_qubits=flag_qubits, midcircuit_meas=False)
+                            output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                    elif counts:
+                        # Single counts dict - same data for all timesteps (unusual but handle it)
+                        log_to_console(f"Found single counts dict with {len(counts)} entries")
+                        for T_total in T_list:
+                            log_to_console(f"Processing timestep T={T_total}")
+                            pts, cnts = load_samples(counts, T_total, logger=log_to_console,
+                                                     flag_qubits=flag_qubits, midcircuit_meas=False)
+                            output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
+                    else:
+                        # Could not find counts - show structure for debugging
+                        log_to_console("ERROR: Could not find counts data in IonQ result structure")
+                        log_to_console(f"Result keys: {list(result.keys())}")
+                        _state.qlbm_job_upload_error = "Could not find counts data in uploaded file. Check file format."
+                        _state.qlbm_job_is_processing = False
+                        return
         
         if not output:
             _state.qlbm_job_upload_error = "No valid data extracted from job result. Check timesteps and file format."

utils/EBU_Quantum/with_body/base_functions_body.py

@@ -602,7 +602,7 @@ def check_gridpoint(grid_point, X_Holed, Y_Holed):
 
     # Check for hole
     if np.isnan(x) or np.isnan(y):
-        warnings.warn(f"Warning: Grid point ({i}, {j}) lies inside the hole (NaN).")
+        # warnings.warn(f"Warning: Grid point ({i}, {j}) lies inside the hole (NaN).")
         return False
     
     return True