Upload Window : Em

em/simulation.py

@@ -1436,4 +1436,268 @@ def update_value_display(point):
             text = f"Index: ({ix}, {iy}) | Position: ({x_code:.3f}, {y_code:.3f})\nValue: {value:.3e}"
 
     plotter.add_text(text, name="value_text", position="lower_left", color="black", font_size=10)
-    ctrl.view_update()
+    ctrl.view_update()
+
+
+# ---------------------------------------------------------------------------
+# EM Job Result Upload Processing
+# ---------------------------------------------------------------------------
+
+def process_uploaded_em_job_result():
+    """
+    Process an uploaded IBM/IonQ EM job result JSON file 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)
+    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, ...]}
+    """
+    import base64
+    import json
+    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."
+        return
+    
+    # Reset messages
+    state.em_job_upload_error = ""
+    state.em_job_upload_success = ""
+    state.em_job_is_processing = True
+    
+    try:
+        from .simulation import log_to_console
+    except ImportError:
+        def log_to_console(msg):
+            print(msg)
+    
+    log_to_console("Processing uploaded EM job result...")
+    
+    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()
+        
+        # Parse monitor point tuple string "(x, y)"
+        monitor_point_str = str(state.em_job_monitor_point or "(0, 0)").strip()
+        try:
+            # Remove parentheses and split by comma
+            cleaned = monitor_point_str.strip("() ")
+            parts = [p.strip() for p in cleaned.split(",")]
+            monitor_x = int(parts[0]) if len(parts) > 0 else 0
+            monitor_y = int(parts[1]) if len(parts) > 1 else 0
+        except (ValueError, IndexError):
+            monitor_x, monitor_y = 0, 0
+        
+        total_time = float(state.em_job_total_time or 1.0)
+        snapshot_dt = float(state.em_job_snapshot_dt or 0.1)
+        nx = int(state.em_job_nx or 4)
+        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
+        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 not field_values:
+            state.em_job_upload_error = "Could not extract field values from JSON. Check file format."
+            state.em_job_is_processing = False
+            return
+        
+        # Generate times if not provided
+        if not times:
+            # Use create_time_frames from delta_impulse_generator
+            try:
+                times = create_time_frames(total_time, snapshot_dt)
+            except:
+                # Fallback: generate linearly
+                num_steps = len(field_values)
+                times = [i * snapshot_dt for i in range(num_steps)]
+        
+        # Ensure times matches field_values length
+        if len(times) != len(field_values):
+            log_to_console(f"Warning: times ({len(times)}) != field_values ({len(field_values)}), regenerating times")
+            num_steps = len(field_values)
+            times = [i * snapshot_dt for i in range(num_steps)]
+        
+        log_to_console(f"Building time-series plot: {len(field_values)} points")
+        
+        # Build Plotly figure
+        fig = go.Figure()
+        
+        # Determine grid dimensions for label
+        if field_type == 'Ez':
+            gw, gh = nx, nx
+        elif field_type == 'Hx':
+            gw, gh = nx, nx - 1
+        else:
+            gw, gh = nx - 1, nx
+        
+        from .utils import normalized_position_label
+        label = normalized_position_label(monitor_x, monitor_y, gw, gh)
+        
+        # Color based on field type
+        if field_type == 'Ez':
+            color = "#d32f2f"  # Red
+        elif field_type == 'Hx':
+            color = "#388e3c"  # Green
+        else:
+            color = "#1976d2"  # Blue
+        
+        fig.add_trace(
+            go.Scatter(
+                x=list(times),
+                y=[float(v) for v in field_values],
+                mode='lines+markers',
+                name=f"{field_type} @ {label}",
+                line=dict(color=color, width=2.5),
+                marker=dict(size=7, symbol="circle", color=color),
+                hovertemplate=f"{field_type} | t=%{{x:.3f}}s<br>Value=%{{y:.6g}}<extra>{label}</extra>",
+            )
+        )
+        
+        max_abs = max((abs(float(v)) for v in field_values), default=1.0)
+        pad = 0.12 * max_abs if max_abs > 0 else 0.1
+        
+        fig.update_layout(
+            title=f"{platform} QPU Time Series (Uploaded) - {field_type} @ {label}",
+            height=660, width=900,
+            margin=dict(l=50, r=30, t=50, b=50),
+            hovermode="x unified",
+            legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1, title_text=""),
+            paper_bgcolor="#FFFFFF",
+            plot_bgcolor="#FFFFFF",
+        )
+        fig.update_xaxes(title_text="Time (s)", title_font=dict(size=22), tickfont=dict(size=16), showgrid=True, gridcolor="rgba(0,0,0,.06)")
+        fig.update_yaxes(title_text="Field Value", title_font=dict(size=22), tickfont=dict(size=16), showgrid=True, gridcolor="rgba(0,0,0,.06)")
+        fig.update_yaxes(range=[-max_abs - pad, max_abs + pad])
+        
+        # Cache the figure for export
+        qpu_ts_cache["fig"] = fig
+        qpu_ts_cache["times"] = list(times)
+        qpu_ts_cache["series_map"] = {(field_type, monitor_x, monitor_y): list(field_values)}
+        qpu_ts_cache["field"] = field_type
+        qpu_ts_cache["unique_fields"] = [field_type]
+        
+        # Update the Plotly figure widget
+        try:
+            ctrl.qpu_ts_update(fig)
+        except Exception:
+            pass
+        
+        # Update state
+        state.simulation_has_run = True
+        state.qpu_ts_ready = True
+        state.qpu_plot_style = "width: 900px; height: 660px; margin: 0 auto;"
+        state.qpu_plot_field_options = ["All", field_type]
+        state.qpu_plot_filter = "All"
+        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}"
+        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}")
+        import traceback
+        log_to_console(traceback.format_exc())
+    finally:
+        state.em_job_is_processing = False

em/state.py

@@ -297,6 +297,18 @@ def _init_state_defaults():
         "simulation_progress": 0,
         "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_field_type": "Ez",
+        "em_job_monitor_point": "(0, 0)",
+        "em_job_total_time": 1.0,
+        "em_job_snapshot_dt": 0.1,
+        "em_job_nx": 4,
     })
 
     # Ensure hole snap state exists

em/ui.py

@@ -11,7 +11,7 @@ from .state import state, ctrl, get_server
 from .globals import plotter, GRID_SIZES
 from .geometry import build_geometry_placeholder as _build_geometry_placeholder
 from .excitation import build_excitation_placeholder as _build_excitation_placeholder
-from .simulation import run_simulation_only, reset_to_defaults, stop_simulation_handler
+from .simulation import run_simulation_only, reset_to_defaults, stop_simulation_handler, process_uploaded_em_job_result
 from .exports import (
     export_vtk, export_vtk_all_frames, export_mp4,
     export_sim_timeseries_csv, export_sim_timeseries_png, export_sim_timeseries_html,
@@ -103,6 +103,7 @@ def build_ui():
                 _build_backends_card()
                 _build_output_preferences_card()
                 _build_run_buttons()
+                _build_job_upload_card()
                 vuetify3.VSpacer()
                 _build_reset_button()
 
@@ -490,6 +491,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;"):
+            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):
+                    vuetify3.VSelect(
+                        label="Platform",
+                        v_model=("em_job_platform", "IBM"),
+                        items=("['IBM', 'IonQ']",),
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                    )
+                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):
+                    vuetify3.VTextField(
+                        label="Monitor Point (x, y)",
+                        v_model=("em_job_monitor_point", "(0, 0)"),
+                        density="compact",
+                        hide_details=True,
+                        color="primary",
+                        placeholder="(x, y)",
+                    )
+            
+            # Time and grid parameters row
+            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.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.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",
+                    )
+            
+            # Success message
+            vuetify3.VAlert(
+                v_if="em_job_upload_success",
+                type="success",
+                variant="tonal",
+                density="compact",
+                closable=True,
+                children=["{{ em_job_upload_success }}"],
+                classes="mt-2",
+            )
+            
+            # Error message
+            vuetify3.VAlert(
+                v_if="em_job_upload_error",
+                type="error",
+                variant="tonal",
+                density="compact",
+                closable=True,
+                children=["{{ em_job_upload_error }}"],
+                classes="mt-2",
+            )
+
+
 def _build_run_buttons():
     """Build the Run and Stop buttons row."""
     with vuetify3.VRow(dense=True, classes="mb-2"):