EM : IBM/ION Job Retrieve Upload Window

em/simulation.py

@@ -1445,30 +1445,33 @@ def update_value_display(point):
 
 def process_uploaded_em_job_result():
     """
-    Process an uploaded IBM/IonQ EM job result JSON file and generate a time-series plot.
+    Process an IBM/IonQ EM job by retrieving it directly using the Job ID and generate a time-series plot.
     
     This function:
-    1. Decodes the uploaded file (base64 -> JSON)
-    2. Parses the job result to extract field values (expectation values or counts)
+    1. Takes the Job ID from user input
+    2. Connects to IBM/IonQ based on platform selection and retrieves the job
+    3. Extracts expectation values (evs) from Estimator results and converts them to field magnitudes
     3. Builds time frames based on user-specified T and dt
     4. Generates a Plotly time-series figure
     
-    Required JSON structure (example):
-    - IBM: List of expectation values or PrimitiveResult
-    - IonQ: Dict with "field_values" or list of values
-    - Simple format: {"field_values": [0.1, 0.2, ...], "times": [0.0, 0.1, ...]}
+    Note:
+    - This pathway expects the job was submitted by this EM workflow (Estimator-based).
+    - The job is assumed to contain one expectation value per time frame.
     """
-    import base64
-    import json
+    import os
     import plotly.graph_objects as go
     
     if not state.bound:
         return
     
-    # Validate file upload
-    uploaded = state.em_job_upload
-    if not uploaded:
-        state.em_job_upload_error = "No file uploaded. Please select a JSON file."
+    # Validate Job ID
+    job_id = None
+    if getattr(state, "em_job_id", None) and str(state.em_job_id).strip():
+        job_id = str(state.em_job_id).strip()
+        if job_id.endswith(".json"):
+            job_id = job_id[:-5]
+    if not job_id:
+        state.em_job_upload_error = "No Job ID provided. Please enter a Job ID."
         return
     
     # Reset messages
@@ -1482,28 +1485,9 @@ def process_uploaded_em_job_result():
         def log_to_console(msg):
             print(msg)
     
-    log_to_console("Processing uploaded EM job result...")
+    log_to_console(f"Processing EM job result for 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.em_job_upload_filename = filename
-        log_to_console(f"Processing file: {filename}")
-        
-        # Decode content
-        content = file_data.get("content", "") if isinstance(file_data, dict) else ""
-        
-        if isinstance(content, bytes):
-            json_str = content.decode("utf-8")
-        else:
-            if content.startswith("data:"):
-                content = content.split(",", 1)[1]
-            raw_bytes = base64.b64decode(content)
-            json_str = raw_bytes.decode("utf-8")
-        
         # Parse parameters from UI
         field_type = str(state.em_job_field_type or "Ez").strip()
         
@@ -1524,77 +1508,125 @@ def process_uploaded_em_job_result():
         platform = str(state.em_job_platform or "IBM")
         
         log_to_console(f"Parameters: field={field_type}, pos=({monitor_x},{monitor_y}), T={total_time}, dt={snapshot_dt}, nx={nx}, platform={platform}")
-        
-        # Parse JSON
-        result = json.loads(json_str)
-        
-        # Extract field values based on result structure
+
+        # Retrieve job results from provider
         field_values = []
         times = []
-        
-        # Try different result formats
-        if isinstance(result, dict):
-            # Format 1: {"field_values": [...], "times": [...]}
-            if "field_values" in result:
-                field_values = result["field_values"]
-                times = result.get("times", None)
-                log_to_console(f"Found 'field_values' key with {len(field_values)} values")
-            
-            # Format 2: {"results": {...}} with key -> value mapping
-            elif "results" in result:
-                results_dict = result["results"]
-                # Sort by key (time index) and extract values
-                sorted_keys = sorted(results_dict.keys(), key=lambda x: float(x) if x.replace('.','').isdigit() else 0)
-                field_values = [results_dict[k] for k in sorted_keys]
-                log_to_console(f"Found 'results' dict with {len(field_values)} entries")
-            
-            # Format 3: {"expectation_values": [...]}
-            elif "expectation_values" in result:
-                exp_vals = result["expectation_values"]
-                # Convert expectation values to field values: sqrt((1 - z_exp) / 2)
-                field_values = [np.sqrt((1 - float(z)) / 2) for z in exp_vals]
-                log_to_console(f"Found 'expectation_values' with {len(field_values)} values, converted to field values")
-            
-            # Format 4: IBM RuntimeEncoder result with nested structure
-            elif "pub_results" in result or "results" in result:
-                pub_results = result.get("pub_results", result.get("results", []))
-                for pr in pub_results:
-                    if isinstance(pr, dict) and "data" in pr:
-                        data = pr["data"]
-                        if "evs" in data:
-                            z_exp = float(data["evs"])
-                            field_values.append(np.sqrt((1 - z_exp) / 2))
-                log_to_console(f"Parsed {len(field_values)} values from pub_results")
-            
-            else:
-                # Try to use the dict values directly if they look numeric
-                if all(isinstance(v, (int, float)) for v in result.values()):
-                    sorted_keys = sorted(result.keys())
-                    field_values = [result[k] for k in sorted_keys]
-                    log_to_console(f"Using dict values directly: {len(field_values)} values")
-        
-        elif isinstance(result, list):
-            # Format 5: Simple list of values
-            if all(isinstance(v, (int, float)) for v in result):
-                field_values = result
-                log_to_console(f"Simple list with {len(field_values)} values")
-            
-            # Format 6: List of dicts (e.g., IBM PrimitiveResult-like)
-            elif all(isinstance(v, dict) for v in result):
-                for item in result:
-                    if "evs" in item:
-                        z_exp = float(item["evs"])
-                        field_values.append(np.sqrt((1 - z_exp) / 2))
-                    elif "value" in item:
-                        field_values.append(float(item["value"]))
-                    elif "data" in item and isinstance(item["data"], dict):
-                        if "evs" in item["data"]:
-                            z_exp = float(item["data"]["evs"])
-                            field_values.append(np.sqrt((1 - z_exp) / 2))
-                log_to_console(f"Parsed {len(field_values)} values from list of dicts")
+
+        if platform.upper() == "IBM":
+            try:
+                from qiskit_ibm_runtime import QiskitRuntimeService
+            except Exception:
+                state.em_job_upload_error = "qiskit_ibm_runtime package not available. Please install it."
+                state.em_job_is_processing = False
+                return
+
+            try:
+                ibm_token = os.environ.get("API_KEY_IBM_EM")
+                if not ibm_token or not str(ibm_token).strip():
+                    state.em_job_upload_error = "IBM API token not found. Set API_KEY_IBM_EM environment variable."
+                    state.em_job_is_processing = False
+                    return
+                service = QiskitRuntimeService(
+                    channel="ibm_cloud",
+                    token=ibm_token,
+                    instance="crn:v1:bluemix:public:quantum-computing:us-east:a/15157e4350c04a9dab51b8b8a4a93c86:e29afd91-64bf-4a82-8dbf-731e6c213595::",
+                )
+            except Exception as e:
+                state.em_job_upload_error = f"Failed to connect to IBM Quantum: {e}"
+                state.em_job_is_processing = False
+                return
+
+            try:
+                job = service.job(job_id)
+            except Exception as e:
+                state.em_job_upload_error = f"Failed to retrieve IBM job: {e}"
+                state.em_job_is_processing = False
+                return
+
+            try:
+                status = job.status()
+                status_name = status.name if hasattr(status, "name") else str(status)
+                if status_name not in ("DONE", "COMPLETED"):
+                    state.em_job_upload_error = f"Job is not complete. Current status: {status_name}"
+                    state.em_job_is_processing = False
+                    return
+            except Exception:
+                pass
+
+            try:
+                # Support both shapes:
+                # - PrimitiveResult: iterable of pubs -> pub.data.evs
+                # - list-like result where each entry has .data.evs
+                res = job.result()
+                if hasattr(res, "__iter__"):
+                    for pub in res:
+                        data = getattr(pub, "data", None)
+                        evs = getattr(data, "evs", None) if data is not None else None
+                        if evs is not None:
+                            z_exp = float(np.array(evs).reshape(-1)[0])
+                            field_values.append(float(np.sqrt((1 - z_exp) / 2)))
+                elif hasattr(res, "data") and hasattr(res.data, "evs"):
+                    z_exp = float(np.array(res.data.evs).reshape(-1)[0])
+                    field_values.append(float(np.sqrt((1 - z_exp) / 2)))
+            except Exception as e:
+                state.em_job_upload_error = f"Failed to get job results: {e}"
+                state.em_job_is_processing = False
+                return
+
+        else:
+            # IonQ pathway (Estimator-based in this app)
+            try:
+                from qiskit_ionq import IonQProvider
+            except Exception:
+                state.em_job_upload_error = "qiskit_ionq package not available. Please install it."
+                state.em_job_is_processing = False
+                return
+
+            ionq_token = os.environ.get("API_KEY_IONQ_EM")
+            if not ionq_token or not str(ionq_token).strip():
+                state.em_job_upload_error = "IonQ API token not found. Set API_KEY_IONQ_EM environment variable."
+                state.em_job_is_processing = False
+                return
+            os.environ.setdefault("IONQ_API_TOKEN", ionq_token)
+
+            try:
+                provider = IonQProvider()
+                job = provider.retrieve_job(job_id)
+            except Exception as e:
+                state.em_job_upload_error = f"Failed to retrieve IonQ job: {e}"
+                state.em_job_is_processing = False
+                return
+
+            try:
+                status = job.status()
+                status_name = status.name if hasattr(status, "name") else str(status)
+                if status_name not in ("DONE", "COMPLETED"):
+                    state.em_job_upload_error = f"Job is not complete. Current status: {status_name}"
+                    state.em_job_is_processing = False
+                    return
+            except Exception:
+                pass
+
+            try:
+                res = job.result()
+                if hasattr(res, "__iter__"):
+                    for pub in res:
+                        data = getattr(pub, "data", None)
+                        evs = getattr(data, "evs", None) if data is not None else None
+                        if evs is not None:
+                            z_exp = float(np.array(evs).reshape(-1)[0])
+                            field_values.append(float(np.sqrt((1 - z_exp) / 2)))
+                elif hasattr(res, "data") and hasattr(res.data, "evs"):
+                    z_exp = float(np.array(res.data.evs).reshape(-1)[0])
+                    field_values.append(float(np.sqrt((1 - z_exp) / 2)))
+            except Exception as e:
+                state.em_job_upload_error = f"Failed to get job results: {e}"
+                state.em_job_is_processing = False
+                return
         
         if not field_values:
-            state.em_job_upload_error = "Could not extract field values from JSON. Check file format."
+            state.em_job_upload_error = "No field values extracted from job. Ensure the job was submitted by the EM Estimator workflow."
             state.em_job_is_processing = False
             return
         
@@ -1688,12 +1720,8 @@ def process_uploaded_em_job_result():
         state.qpu_plot_position_options = ["All positions", label]
         state.qpu_plot_position_filter = "All positions"
         
-        state.em_job_upload_success = f"✓ Successfully processed {len(field_values)} time step(s) from {filename}"
+        state.em_job_upload_success = f"✓ Successfully processed {len(field_values)} time step(s) from {platform} job {job_id}"
         log_to_console(f"Upload processing complete: {len(field_values)} points plotted")
-        
-    except json.JSONDecodeError as e:
-        state.em_job_upload_error = f"Invalid JSON file: {e}"
-        log_to_console(f"JSON decode error: {e}")
     except Exception as e:
         state.em_job_upload_error = f"Error processing job result: {e}"
         log_to_console(f"Processing error: {e}")

em/state.py

@@ -298,12 +298,11 @@ def _init_state_defaults():
         "show_progress": False,
         "console_logs": "Console initialized...\n",
         # --- EM Job Upload State ---
-        "em_job_upload": None,
-        "em_job_upload_filename": "",
         "em_job_upload_error": "",
         "em_job_upload_success": "",
         "em_job_is_processing": False,
         "em_job_platform": "IBM",
+        "em_job_id": "",
         "em_job_field_type": "Ez",
         "em_job_monitor_point": "(0, 0)",
         "em_job_total_time": 1.0,

em/ui.py

@@ -494,100 +494,127 @@ def _build_output_preferences_card():
 def _build_job_upload_card():
     """Build the Job Result Upload card for loading previously saved QPU results."""
     with vuetify3.VCard(classes="mb-1", style="font-size: 0.8rem;"):
-        with vuetify3.VCardTitle("Upload Job Results", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
+        with vuetify3.VCardTitle("Upload Results", classes="text-subtitle-1 text-primary", style="font-size: 0.9rem; padding: 6px 10px;"):
             pass
         with vuetify3.VCardText(classes="py-1 px-2"):
-            trame_html.Div("Load previously saved IBM/IonQ QPU job results (JSON format)", 
-                     classes="text-caption text-medium-emphasis mb-2")
-            
-            # Platform and Field Type row
-            with vuetify3.VRow(dense=True, classes="mb-2"):
-                with vuetify3.VCol(cols=6):
+            trame_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=("em_job_platform", "IBM"),
                         items=("['IBM', 'IonQ']",),
                         density="compact",
                         hide_details=True,
                         color="primary",
+                        classes="mb-2",
+                        prepend_icon="mdi-chip",
                     )
-                with vuetify3.VCol(cols=6):
-                    vuetify3.VSelect(
-                        label="Field Type",
-                        v_model=("em_job_field_type", "Ez"),
-                        items=("['Ez', 'Hx', 'Hy']",),
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                    )
-            
-            # Monitor position row
-            with vuetify3.VRow(dense=True, classes="mb-2"):
-                with vuetify3.VCol(cols=12):
+                trame_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(
-                        label="Monitor Point (x, y)",
-                        v_model=("em_job_monitor_point", "(0, 0)"),
+                        v_bind="props",
+                        label="Job ID",
+                        v_model=("em_job_id", ""),
                         density="compact",
                         hide_details=True,
                         color="primary",
-                        placeholder="(x, y)",
+                        classes="mb-2",
+                        placeholder="e.g., 019b368e-6e22-7525-8512-fd16e0503673",
+                        prepend_icon="mdi-identifier",
                     )
-            
-            # Time and grid parameters row
+                trame_html.Span("Enter the Job ID (UUID format from IBM or IonQ)")
+
+            # Field / monitor / time parameters
+            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(
+                                v_bind="props",
+                                label="Field Type",
+                                v_model=("em_job_field_type", "Ez"),
+                                items=("['Ez', 'Hx', 'Hy']",),
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                            )
+                        trame_html.Span("Select which field component to plot (Ez, Hx, Hy)")
+                with vuetify3.VCol(cols=6):
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VTextField(
+                                v_bind="props",
+                                label="Monitor Point (x, y)",
+                                v_model=("em_job_monitor_point", "(0, 0)"),
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                                placeholder="(x, y)",
+                            )
+                        trame_html.Span("Integer grid indices of the monitor point")
+
             with vuetify3.VRow(dense=True, classes="mb-2"):
                 with vuetify3.VCol(cols=4):
-                    vuetify3.VTextField(
-                        label="Total Time (T)",
-                        v_model=("em_job_total_time", 1.0),
-                        type="number",
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                    )
-                with vuetify3.VCol(cols=4):
-                    vuetify3.VTextField(
-                        label="Snapshot Δt",
-                        v_model=("em_job_snapshot_dt", 0.1),
-                        type="number",
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                    )
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VTextField(
+                                v_bind="props",
+                                label="Total Time (T)",
+                                v_model=("em_job_total_time", 1.0),
+                                type="number",
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                            )
+                        trame_html.Span("Total simulation time")
                 with vuetify3.VCol(cols=4):
-                    vuetify3.VTextField(
-                        label="No. of Points per Direction",
-                        v_model=("em_job_nx", 4),
-                        type="number",
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                    )
-            
-            # 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=("em_job_upload", None),
-                        accept=".json",
-                        prepend_icon="mdi-file-upload",
-                        density="compact",
-                        hide_details=True,
-                        color="primary",
-                        show_size=True,
-                        clearable=True,
-                    )
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VTextField(
+                                v_bind="props",
+                                label="Snapshot Δt",
+                                v_model=("em_job_snapshot_dt", 0.1),
+                                type="number",
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                            )
+                        trame_html.Span("Time between snapshots")
                 with vuetify3.VCol(cols=4):
-                    vuetify3.VBtn(
-                        text="Generate",
-                        color="secondary",
-                        variant="tonal",
-                        block=True,
-                        disabled=("!em_job_upload || em_job_is_processing", True),
-                        loading=("em_job_is_processing", False),
-                        click=process_uploaded_em_job_result,
-                        prepend_icon="mdi-chart-box-outline",
-                    )
+                    with vuetify3.VTooltip(location="top"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VTextField(
+                                v_bind="props",
+                                label="No. of Points per Direction",
+                                v_model=("em_job_nx", 4),
+                                type="number",
+                                density="compact",
+                                hide_details=True,
+                                color="primary",
+                            )
+                        trame_html.Span("Grid dimension nx (grid is nx × nx)")
+
+            vuetify3.VBtn(
+                text="Retrieve & Generate Plot",
+                color="secondary",
+                variant="tonal",
+                block=True,
+                disabled=("!em_job_id || em_job_is_processing", True),
+                loading=("em_job_is_processing", False),
+                click=process_uploaded_em_job_result,
+                prepend_icon="mdi-chart-box-outline",
+                classes="mb-2",
+            )
             
             # Success message
             vuetify3.VAlert(

qlbm/qlbm_sample_app.py

@@ -820,7 +820,7 @@ def run_sampling_hw_ionq(
     # IonQ job status polling
     last_status = None
     poll_count = 0
-    max_polls = 600  # ~10 minutes with 1s interval
+    max_polls = 60000  # ~10 minutes with 1s interval
     
     while poll_count < max_polls:
       try: