QLBM IONQ Upload Window

qlbm_embedded.py

@@ -314,16 +314,17 @@ def init_state():
         "qlbm_qiskit_fig": None,  # Stores the Plotly figure for Qiskit results
         
         # Job upload state (for loading previously saved QPU job results)
-        "qlbm_job_upload": None,  # File upload content
+        "qlbm_job_upload": None,  # File upload content (optional, for extracting job ID from filename)
         "qlbm_job_upload_filename": "",  # Display the uploaded filename
         "qlbm_job_upload_error": "",  # Error message for upload
         "qlbm_job_upload_success": "",  # Success message for upload
-        "qlbm_job_platform": "IBM",  # Platform: "IBM" or "IonQ"
+        "qlbm_job_platform": "IonQ",  # Platform: IonQ only now
+        "qlbm_job_id": "",  # Job ID text field for direct entry
         "qlbm_job_total_time": 3,  # Total time T (generates T_list = [1..T])
         "qlbm_job_output_resolution": 40,  # Grid resolution for density estimation
         "qlbm_job_is_processing": False,  # True when processing uploaded job
         "qlbm_job_flag_qubits": True,  # Whether flag qubits were used
-        "qlbm_job_midcircuit_meas": True,  # Whether mid-circuit measurement was used (IBM only)
+        "qlbm_job_midcircuit_meas": False,  # IonQ uses midcircuit_meas=False
     })
     _initialized = True
 
@@ -1199,13 +1200,14 @@ def _run_qiskit_simulation(progress_callback=None):
 # --- Job Result Upload Processing ---
 def process_uploaded_job_result():
     """
-    Process an uploaded IBM/IonQ job result JSON file and generate the Plotly figure.
+    Process an IonQ job by retrieving it directly using the Job ID.
     
     This function:
-    1. Decodes the uploaded file (base64 -> JSON)
-    2. Parses the job result based on platform (IBM uses RuntimeDecoder, IonQ uses plain dict)
-    3. Calls load_samples/estimate_density for each timestep
-    4. Generates the slider figure using plot_density_isosurface_slider
+    1. Takes the Job ID from user input (or extracts from uploaded filename)
+    2. Connects to IonQ and retrieves the job
+    3. Calls job.get_counts(i) for each timestep (same as run_sampling_hw_ionq)
+    4. Calls load_samples/estimate_density for each timestep
+    5. Generates the slider figure using plot_density_isosurface_slider
     """
     global simulation_data_frames, simulation_times, current_grid_object
     
@@ -1218,45 +1220,44 @@ def process_uploaded_job_result():
         log_to_console("Error: visualize_counts module not available")
         return
     
-    # Validate file upload
-    uploaded = _state.qlbm_job_upload
-    if not uploaded:
-        _state.qlbm_job_upload_error = "No file uploaded. Please select a JSON file."
+    # Get job ID - either from text field or from uploaded filename
+    job_id = None
+    
+    # First try the text field
+    if _state.qlbm_job_id and str(_state.qlbm_job_id).strip():
+        job_id = str(_state.qlbm_job_id).strip()
+        # Remove .json extension if present
+        if job_id.endswith(".json"):
+            job_id = job_id[:-5]
+        log_to_console(f"Using Job ID from text field: {job_id}")
+    else:
+        # Fallback: try to get from uploaded file name
+        uploaded = _state.qlbm_job_upload
+        if uploaded:
+            file_data = uploaded[0] if isinstance(uploaded, list) else uploaded
+            filename = file_data.get("name", "") if isinstance(file_data, dict) else ""
+            if filename:
+                # Extract job ID from filename (remove .json and any extra text)
+                job_id = filename.replace(".json", "").strip()
+                # Handle filenames like "019b368e-6e22-7525-8512-fd16e0503673 (1).json"
+                # Remove any trailing parenthetical like " (1)"
+                import re
+                job_id = re.sub(r'\s*\(\d+\)\s*$', '', job_id)
+                log_to_console(f"Extracted Job ID from filename: {job_id}")
+    
+    if not job_id:
+        _state.qlbm_job_upload_error = "No Job ID provided. Please enter a Job ID or upload a JSON file."
         return
     
     # Reset messages
     _state.qlbm_job_upload_error = ""
     _state.qlbm_job_upload_success = ""
     _state.qlbm_job_is_processing = True
-    log_to_console("Processing uploaded job result...")
+    _state.qlbm_job_upload_filename = job_id
+    log_to_console(f"Processing IonQ Job ID: {job_id}")
     
     try:
-        # Handle list or single file
-        file_data = uploaded[0] if isinstance(uploaded, list) else uploaded
-        
-        # Get filename for display
-        filename = file_data.get("name", "unknown.json") if isinstance(file_data, dict) else "unknown.json"
-        _state.qlbm_job_upload_filename = filename
-        log_to_console(f"Processing file: {filename}")
-        
-        # Decode content - handle both bytes and string (base64 data URI)
-        content = file_data.get("content", "") if isinstance(file_data, dict) else ""
-        
-        # Check if content is bytes or string
-        if isinstance(content, bytes):
-            # Content is already raw bytes, decode directly
-            json_str = content.decode("utf-8")
-            log_to_console("Content received as raw bytes")
-        else:
-            # Content is a string, possibly base64 data URI
-            if content.startswith("data:"):
-                content = content.split(",", 1)[1]  # Remove data URI prefix
-            raw_bytes = base64.b64decode(content)
-            json_str = raw_bytes.decode("utf-8")
-            log_to_console("Content decoded from base64 string")
-        
         # Parse timesteps from user input
-        # User provides Total Time T, we generate T_list = [1, 2, ..., T]
         try:
             total_time = int(_state.qlbm_job_total_time or 3)
             if total_time < 1:
@@ -1270,117 +1271,119 @@ def process_uploaded_job_result():
         log_to_console(f"Timesteps to process: {T_list}")
         
         # Get processing parameters
-        platform = _state.qlbm_job_platform or "IBM"
         output_resolution = int(_state.qlbm_job_output_resolution or 40)
-        # Defaulting to True as per user request, and hiding from UI
+        # Fixed parameters for IonQ (same as run_sampling_hw_ionq)
         flag_qubits = True
-        midcircuit_meas = True
+        midcircuit_meas = False  # IonQ uses midcircuit_meas=False
         
-        log_to_console(f"Platform: {platform}, Resolution: {output_resolution}, Flag qubits: {flag_qubits}")
+        log_to_console(f"Resolution: {output_resolution}, Flag qubits: {flag_qubits}, Midcircuit meas: {midcircuit_meas}")
         
-        # Parse JSON based on platform
-        if platform == "IBM":
-            # IBM uses RuntimeDecoder for proper result parsing
-            try:
-                from qiskit_ibm_runtime import RuntimeDecoder
-                result = json.loads(json_str, cls=RuntimeDecoder)
-                log_to_console("Parsed IBM result with RuntimeDecoder")
-            except ImportError:
-                # Fallback to plain JSON if RuntimeDecoder not available
-                result = json.loads(json_str)
-                log_to_console("Warning: RuntimeDecoder not available, using plain JSON")
-            except Exception as e:
-                # Try plain JSON as fallback
-                result = json.loads(json_str)
-                log_to_console(f"RuntimeDecoder failed ({e}), using plain JSON")
-        else:
-            # IonQ uses plain JSON
-            result = json.loads(json_str)
-            log_to_console("Parsed IonQ result as plain JSON")
+        # === Connect to IonQ and retrieve the job ===
+        log_to_console("Connecting to IonQ...")
+        
+        try:
+            from qiskit_ionq import IonQProvider
+        except ImportError:
+            _state.qlbm_job_upload_error = "qiskit_ionq package not available. Please install it."
+            _state.qlbm_job_is_processing = False
+            log_to_console("Error: qiskit_ionq not installed")
+            return
+        
+        # Get API token from environment (same pattern as run_sampling_hw_ionq)
+        ionq_token = os.environ.get("API_KEY_IONQ_QLBM") or os.environ.get("IONQ_API_TOKEN")
+        if not ionq_token:
+            _state.qlbm_job_upload_error = "IonQ API token not found. Set API_KEY_IONQ_QLBM environment variable."
+            _state.qlbm_job_is_processing = False
+            log_to_console("Error: IonQ API token not found in environment")
+            return
+        
+        # Set the IONQ_API_TOKEN env var so IonQProvider() can find it (same as run_sampling_hw_ionq)
+        os.environ.setdefault("IONQ_API_TOKEN", ionq_token)
         
-        # Process each timestep
+        # Set up the IonQ provider and backend (IonQProvider reads from IONQ_API_TOKEN env var)
+        provider = IonQProvider()
+        backend = provider.get_backend("qpu.forte-enterprise-1")
+        backend_name = backend.name if isinstance(backend.name, str) else backend.name()
+        log_to_console(f"Connected to IonQ backend: {backend_name}")
+        
+        # Retrieve the job
+        log_to_console(f"Retrieving job: {job_id}")
+        try:
+            job = backend.retrieve_job(job_id)
+        except Exception as e:
+            _state.qlbm_job_upload_error = f"Failed to retrieve job: {e}"
+            _state.qlbm_job_is_processing = False
+            log_to_console(f"Error retrieving job: {e}")
+            return
+        
+        # Check job status
+        try:
+            status = job.status()
+            status_name = status.name if hasattr(status, 'name') else str(status)
+            log_to_console(f"Job status: {status_name}")
+            
+            if status_name not in ('DONE', 'COMPLETED'):
+                _state.qlbm_job_upload_error = f"Job is not complete. Current status: {status_name}"
+                _state.qlbm_job_is_processing = False
+                return
+        except Exception as e:
+            log_to_console(f"Warning: Could not check job status: {e}")
+        
+        # === Process results (same as run_sampling_hw_ionq) ===
+        log_to_console("Processing job results...")
         output = []
         
-        # Determine how to extract counts based on result structure
-        if platform == "IBM":
-            # 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)):
-                    try:
-                        # Try the PrimitiveResult API
-                        if hasattr(pub, 'join_data'):
-                            joined = pub.join_data()
-                            counts = joined.get_counts()
-                        elif hasattr(pub, 'data'):
-                            # Older API
-                            counts = pub.data.get_counts() if hasattr(pub.data, 'get_counts') else dict(pub.data)
-                        elif isinstance(pub, dict):
-                            counts = pub
-                        else:
-                            counts = dict(pub)
-                        
-                        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=midcircuit_meas)
-                        output.append(estimate_density(pts, cnts, bandwidth=0.05, grid_size=output_resolution))
-                    except Exception as e:
-                        log_to_console(f"Error processing timestep {i}: {e}")
-            elif isinstance(result, dict):
-                # Single result or counts dict directly
-                if 'counts' in result:
-                    counts = result['counts']
-                else:
-                    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=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
-            if hasattr(result, 'get_counts'):
-                for i, T_total in enumerate(T_list):
-                    try:
-                        counts = result.get_counts(i)
-                        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))
-                    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}")
-                        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))
-            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))
+        for i, T_total in enumerate(T_list):
+            try:
+                log_to_console(f"Processing timestep T={T_total} (circuit {i})...")
+                
+                # Get counts directly from job (same as run_sampling_hw_ionq)
+                counts = job.get_counts(i)
+                log_to_console(f"  Retrieved {len(counts)} unique bitstrings")
+                
+                # Debug: show a few sample bitstrings
+                sample_count = 0
+                for bs, cnt in counts.items():
+                    if sample_count < 3:
+                        log_to_console(f"    Sample: {bs} (count={cnt})")
+                        sample_count += 1
+                
+                # Process samples (same as run_sampling_hw_ionq)
+                pts, processed_counts = load_samples(
+                    counts, T_total, 
+                    logger=log_to_console,
+                    flag_qubits=flag_qubits, 
+                    midcircuit_meas=midcircuit_meas
+                )
+                log_to_console(f"  load_samples returned {len(pts)} valid sample points")
+                
+                # Estimate density
+                density = estimate_density(pts, processed_counts, bandwidth=0.05, grid_size=output_resolution)
+                output.append(density)
+                
+            except IndexError:
+                log_to_console(f"Warning: No data found for timestep T={T_total} (circuit {i})")
+                break
+            except Exception as e:
+                log_to_console(f"Error processing timestep {i}: {e}")
+                import traceback
+                log_to_console(traceback.format_exc())
         
         if not output:
-            _state.qlbm_job_upload_error = "No valid data extracted from job result. Check timesteps and file format."
+            _state.qlbm_job_upload_error = "No valid data extracted from job. Check timesteps parameter."
             _state.qlbm_job_is_processing = False
             return
         
         log_to_console(f"Processed {len(output)} timestep(s) successfully")
         
         # Generate the Plotly figure
-        fig = plot_density_isosurface_slider(output, T_list)
+        fig = plot_density_isosurface_slider(output, T_list[:len(output)])
         
         # Update state to show results
         _state.qlbm_qiskit_mode = True
         _state.qlbm_qiskit_fig = fig
         _state.qlbm_simulation_has_run = True
-        _state.qlbm_job_upload_success = f"✓ Successfully processed {len(output)} timestep(s) from {filename}"
+        _state.qlbm_job_upload_success = f"✓ Successfully processed {len(output)} timestep(s) from job {job_id}"
         
         # Update the Plotly figure widget
         if hasattr(_ctrl, "qlbm_qiskit_result_update"):
@@ -1388,11 +1391,8 @@ def process_uploaded_job_result():
         
         log_to_console(f"Results ready! {len(output)} frames generated.")
         
-    except json.JSONDecodeError as e:
-        _state.qlbm_job_upload_error = f"Invalid JSON file: {e}"
-        log_to_console(f"JSON decode error: {e}")
     except Exception as e:
-        _state.qlbm_job_upload_error = f"Error processing job result: {e}"
+        _state.qlbm_job_upload_error = f"Error processing job: {e}"
         log_to_console(f"Processing error: {e}")
         import traceback
         log_to_console(traceback.format_exc())
@@ -2393,25 +2393,41 @@ def _build_control_panels(plotter):
             
             # --- Job Result Upload Section ---
             vuetify3.VDivider(classes="my-3")
-            html.Div("Upload Job Results", classes="text-subtitle-2 font-weight-bold text-primary mb-2")
-            html.Div("Load previously saved IBM/IonQ QPU job results (JSON format)", 
+            html.Div("Retrieve IonQ Job Results", classes="text-subtitle-2 font-weight-bold text-primary mb-2")
+            html.Div("Enter the Job ID to retrieve results directly from IonQ", 
                      classes="text-caption text-medium-emphasis mb-2")
             
-            # Platform selector
+            # Job ID input
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VTextField(
+                        v_bind="props",
+                        label="IonQ Job ID",
+                        v_model=("qlbm_job_id", ""),
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                        classes="mb-2",
+                        placeholder="e.g., 019b368e-6e22-7525-8512-fd16e0503673",
+                        prepend_icon="mdi-identifier",
+                    )
+                html.Span("Enter the IonQ Job ID (UUID format)")
+            
+            # Output resolution and Total Time in a row
             with vuetify3.VRow(dense=True, classes="mb-2"):
                 with vuetify3.VCol(cols=6):
                     with vuetify3.VTooltip(location="top"):
                         with vuetify3.Template(v_slot_activator="{ props }"):
-                            vuetify3.VSelect(
+                            vuetify3.VTextField(
                                 v_bind="props",
-                                label="Platform",
-                                v_model=("qlbm_job_platform", "IBM"),
-                                items=("['IBM', 'IonQ']",),
+                                label="Total Time",
+                                v_model=("qlbm_job_total_time", 3),
+                                type="number",
                                 density="compact",
                                 hide_details=True,
                                 color="primary",
                             )
-                        html.Span("Select the quantum hardware provider")
+                        html.Span("Total number of time steps (T) used when running the job")
                 with vuetify3.VCol(cols=6):
                     with vuetify3.VTooltip(location="top"):
                         with vuetify3.Template(v_slot_activator="{ props }"):
@@ -2426,50 +2442,36 @@ def _build_control_panels(plotter):
                             )
                         html.Span("Resolution for 3D visualization. Should be <= Grid Size (2^n).")
             
-            # Timesteps input
-            with vuetify3.VTooltip(location="top"):
-                with vuetify3.Template(v_slot_activator="{ props }"):
-                    vuetify3.VTextField(
-                        v_bind="props",
-                        label="Total Time",
-                        v_model=("qlbm_job_total_time", 3),
-                        type="number",
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                        classes="mb-2",
-                        hint="Enter the total time T used when running the job",
-                    )
-                html.Span("Total number of time steps in the uploaded job")
-            
-            # Advanced options (flag qubits, mid-circuit measurement) - HIDDEN
-            # Defaulting to True for both as per user request
+            # Generate button
+            vuetify3.VBtn(
+                text="Retrieve & Generate Plot",
+                color="secondary",
+                variant="tonal",
+                block=True,
+                disabled=("!qlbm_job_id || qlbm_job_is_processing", True),
+                loading=("qlbm_job_is_processing", False),
+                click=process_uploaded_job_result,
+                prepend_icon="mdi-chart-box-outline",
+                classes="mb-2",
+            )
             
-            # File upload and Generate button
-            with vuetify3.VRow(dense=True, classes="align-center mt-2"):
-                with vuetify3.VCol(cols=8):
-                    vuetify3.VFileInput(
-                        label="Upload Job Result (JSON)",
-                        v_model=("qlbm_job_upload", None),
-                        accept=".json",
-                        prepend_icon="mdi-file-upload",
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                        show_size=True,
-                        clearable=True,
-                    )
-                with vuetify3.VCol(cols=4):
-                    vuetify3.VBtn(
-                        text="Generate",
-                        color="secondary",
-                        variant="tonal",
-                        block=True,
-                        disabled=("!qlbm_job_upload || qlbm_job_is_processing", True),
-                        loading=("qlbm_job_is_processing", False),
-                        click=process_uploaded_job_result,
-                        prepend_icon="mdi-chart-box-outline",
-                    )
+            # Or use file upload (fallback)
+            with vuetify3.VExpansionPanels(variant="accordion", classes="mt-2"):
+                with vuetify3.VExpansionPanel():
+                    vuetify3.VExpansionPanelTitle(children=["Or extract Job ID from JSON filename"])
+                    with vuetify3.VExpansionPanelText():
+                        vuetify3.VFileInput(
+                            label="Upload JSON (for Job ID extraction)",
+                            v_model=("qlbm_job_upload", None),
+                            accept=".json",
+                            prepend_icon="mdi-file-upload",
+                            density="compact",
+                            hide_details=True,
+                            color="primary",
+                            show_size=True,
+                            clearable=True,
+                            hint="The Job ID will be extracted from the filename",
+                        )
             
             # Success message
             vuetify3.VAlert(