QLBM :IBM Jobs and Removed JSON file

qlbm_embedded.py

@@ -313,18 +313,16 @@ def init_state():
         "qlbm_qiskit_backend_available": _QISKIT_BACKEND_AVAILABLE,
         "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 (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": "IonQ",  # Platform: IonQ only now
+        # Job retrieval state (for loading previously saved QPU job results)
+        "qlbm_job_upload_error": "",  # Error message for retrieval
+        "qlbm_job_upload_success": "",  # Success message for retrieval
+        "qlbm_job_platform": "IonQ",  # Platform: IonQ or IBM
         "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_is_processing": False,  # True when processing job
         "qlbm_job_flag_qubits": True,  # Whether flag qubits were used
-        "qlbm_job_midcircuit_meas": False,  # IonQ uses midcircuit_meas=False
+        "qlbm_job_midcircuit_meas": False,  # IonQ uses False, IBM uses True
     })
     _initialized = True
 
@@ -1200,12 +1198,12 @@ def _run_qiskit_simulation(progress_callback=None):
 # --- Job Result Upload Processing ---
 def process_uploaded_job_result():
     """
-    Process an IonQ job by retrieving it directly using the Job ID.
+    Process an IBM or IonQ job by retrieving it directly using the Job ID.
     
     This function:
     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)
+    2. Connects to IBM/IonQ based on platform selection and retrieves the job
+    3. Processes the job results (IBM: job.result(), IonQ: job.get_counts(i))
     4. Calls load_samples/estimate_density for each timestep
     5. Generates the slider figure using plot_density_isosurface_slider
     """
@@ -1220,41 +1218,28 @@ def process_uploaded_job_result():
         log_to_console("Error: visualize_counts module not available")
         return
     
-    # Get job ID - either from text field or from uploaded filename
+    # Get job ID from text field
     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."
+        _state.qlbm_job_upload_error = "No Job ID provided. Please enter a Job ID."
         return
     
+    # Get platform selection
+    platform = _state.qlbm_job_platform or "IonQ"
+    
     # Reset messages
     _state.qlbm_job_upload_error = ""
     _state.qlbm_job_upload_success = ""
     _state.qlbm_job_is_processing = True
-    _state.qlbm_job_upload_filename = job_id
-    log_to_console(f"Processing IonQ Job ID: {job_id}")
+    log_to_console(f"Processing {platform} Job ID: {job_id}")
     
     try:
         # Parse timesteps from user input
@@ -1272,102 +1257,219 @@ def process_uploaded_job_result():
         
         # Get processing parameters
         output_resolution = int(_state.qlbm_job_output_resolution or 40)
-        # Fixed parameters for IonQ (same as run_sampling_hw_ionq)
-        flag_qubits = True
-        midcircuit_meas = False  # IonQ uses midcircuit_meas=False
-        
-        log_to_console(f"Resolution: {output_resolution}, Flag qubits: {flag_qubits}, Midcircuit meas: {midcircuit_meas}")
-        
-        # === 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)
+        # Platform-specific parameters
+        if platform == "IBM":
+            flag_qubits = True
+            midcircuit_meas = True  # IBM uses midcircuit_meas=True
+        else:  # IonQ
+            flag_qubits = True
+            midcircuit_meas = False  # IonQ uses midcircuit_meas=False
         
-        # 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}")
+        log_to_console(f"Platform: {platform}, Resolution: {output_resolution}, Flag qubits: {flag_qubits}, Midcircuit meas: {midcircuit_meas}")
         
-        # 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
+        output = []
         
-        # 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 platform == "IBM":
+            # === IBM Job Retrieval ===
+            log_to_console("Connecting to IBM Quantum...")
             
-            if status_name not in ('DONE', 'COMPLETED'):
-                _state.qlbm_job_upload_error = f"Job is not complete. Current status: {status_name}"
+            try:
+                from qiskit_ibm_runtime import QiskitRuntimeService
+            except ImportError:
+                _state.qlbm_job_upload_error = "qiskit_ibm_runtime package not available. Please install it."
                 _state.qlbm_job_is_processing = False
+                log_to_console("Error: qiskit_ibm_runtime not installed")
                 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 = []
-        
-        for i, T_total in enumerate(T_list):
+            
+            # Get API token from environment
+            ibm_token = os.environ.get("API_KEY_IBM_QLBM")
+            if not ibm_token:
+                _state.qlbm_job_upload_error = "IBM API token not found. Set API_KEY_IBM_QLBM environment variable."
+                _state.qlbm_job_is_processing = False
+                log_to_console("Error: IBM API token not found in environment")
+                return
+            
+            # Set up IBM service (same as run_sampling_hw_ibm)
             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
+                service = QiskitRuntimeService(
+                    channel="ibm_cloud",
+                    token=ibm_token,
+                    instance="crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::",
                 )
-                log_to_console(f"  load_samples returned {len(pts)} valid sample points")
+                log_to_console("Connected to IBM Quantum service")
+            except Exception as e:
+                _state.qlbm_job_upload_error = f"Failed to connect to IBM Quantum: {e}"
+                _state.qlbm_job_is_processing = False
+                log_to_console(f"Error connecting to IBM: {e}")
+                return
+            
+            # Retrieve the job
+            log_to_console(f"Retrieving IBM job: {job_id}")
+            try:
+                job = service.job(job_id)
+            except Exception as e:
+                _state.qlbm_job_upload_error = f"Failed to retrieve IBM 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}")
                 
-                # Estimate density
-                density = estimate_density(pts, processed_counts, bandwidth=0.05, grid_size=output_resolution)
-                output.append(density)
+                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}")
+            
+            # Get results (same as run_sampling_hw_ibm)
+            log_to_console("Retrieving IBM job results...")
+            try:
+                result = job.result()
+                log_to_console("Results retrieved successfully")
+            except Exception as e:
+                _state.qlbm_job_upload_error = f"Failed to get job results: {e}"
+                _state.qlbm_job_is_processing = False
+                log_to_console(f"Error getting results: {e}")
+                return
+            
+            # Process results (same pattern as run_sampling_hw_ibm)
+            log_to_console("Processing IBM job results...")
+            
+            for idx, (T_total, pub) in enumerate(zip(T_list, result)):
+                try:
+                    log_to_console(f"Processing timestep T={T_total} (circuit {idx})...")
+                    
+                    # Get counts (same as run_sampling_hw_ibm)
+                    try:
+                        joined = pub.join_data()
+                        counts = joined.get_counts()
+                    except Exception as e:
+                        log_to_console(f"Error retrieving counts for T={T_total}: {e}")
+                        continue
+                    
+                    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_ibm)
+                    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 Exception as e:
+                    log_to_console(f"Error processing timestep {idx}: {e}")
+                    import traceback
+                    log_to_console(traceback.format_exc())
+        
+        else:
+            # === IonQ Job Retrieval ===
+            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)
+            
+            # 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 IonQ job: {job_id}")
+            try:
+                job = backend.retrieve_job(job_id)
+            except Exception as e:
+                _state.qlbm_job_upload_error = f"Failed to retrieve IonQ 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}")
                 
-            except IndexError:
-                log_to_console(f"Warning: No data found for timestep T={T_total} (circuit {i})")
-                break
+                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"Error processing timestep {i}: {e}")
-                import traceback
-                log_to_console(traceback.format_exc())
+                log_to_console(f"Warning: Could not check job status: {e}")
+            
+            # Process results (same as run_sampling_hw_ionq)
+            log_to_console("Processing IonQ job results...")
+            
+            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. Check timesteps parameter."
@@ -1383,7 +1485,7 @@ def process_uploaded_job_result():
         _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 job {job_id}"
+        _state.qlbm_job_upload_success = f"✓ Successfully processed {len(output)} timestep(s) from {platform} job {job_id}"
         
         # Update the Plotly figure widget
         if hasattr(_ctrl, "qlbm_qiskit_result_update"):
@@ -2393,16 +2495,32 @@ def _build_control_panels(plotter):
             
             # --- Job Result Upload Section ---
             vuetify3.VDivider(classes="my-3")
-            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", 
+            html.Div("Upload Results", classes="text-subtitle-2 font-weight-bold text-primary mb-2")
+            html.Div("Retrieve completed job results from IBM or IonQ using the Job ID", 
                      classes="text-caption text-medium-emphasis mb-2")
             
+            # Platform selector
+            with vuetify3.VTooltip(location="top"):
+                with vuetify3.Template(v_slot_activator="{ props }"):
+                    vuetify3.VSelect(
+                        v_bind="props",
+                        label="Platform",
+                        v_model=("qlbm_job_platform", "IonQ"),
+                        items=("['IBM', 'IonQ']",),
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                        classes="mb-2",
+                        prepend_icon="mdi-chip",
+                    )
+                html.Span("Select the quantum hardware provider (IBM or IonQ)")
+            
             # Job ID input
             with vuetify3.VTooltip(location="top"):
                 with vuetify3.Template(v_slot_activator="{ props }"):
                     vuetify3.VTextField(
                         v_bind="props",
-                        label="IonQ Job ID",
+                        label="Job ID",
                         v_model=("qlbm_job_id", ""),
                         density="compact",
                         hide_details=True,
@@ -2411,7 +2529,7 @@ def _build_control_panels(plotter):
                         placeholder="e.g., 019b368e-6e22-7525-8512-fd16e0503673",
                         prepend_icon="mdi-identifier",
                     )
-                html.Span("Enter the IonQ Job ID (UUID format)")
+                html.Span("Enter the Job ID (UUID format from IBM or IonQ)")
             
             # Output resolution and Total Time in a row
             with vuetify3.VRow(dense=True, classes="mb-2"):
@@ -2455,24 +2573,6 @@ def _build_control_panels(plotter):
                 classes="mb-2",
             )
             
-            # 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(
                 v_if="qlbm_job_upload_success",