PyMieSimX 0.1.3__tar.gz → 0.1.5__tar.gz

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMieSimX
-Version: 0.1.3
+Version: 0.1.5
 Summary: Graphical Dash interface for PyMieSim.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License-Expression: MIT
@@ -112,14 +112,30 @@ The computational API can be used without constructing the Dash application::
 ``PyMieSimX.create_dash_app`` and ``PyMieSimX.OpticalSetupGUI`` remain
 available for applications that need the graphical interface.
 
+Multiple measures
+-----------------
+
+The Parameter Sweep Measures selector accepts several quantities in one run.
+For example, select ``Qsca``, ``Qabs``, and ``Qext`` to compare scattering,
+absorption, and extinction efficiencies. Measures with the same units share a
+plot; different units use separate panels with a shared X axis. CSV exports
+contain a column for each computed measure.
+
+The Python API accepts either a single name or a list, for example
+``run_experiment(..., measure=["Qsca", "Qabs", "Qext"])``. Results include
+``measures`` with every computed name; ``measure`` retains the first name for
+compatibility with existing single-measure callers. Size validation accounts
+for the additional result columns.
+
 Background calculations and limits
 -----------------------------------
 
 Parameter sweeps are submitted to a bounded background worker and reported to
-the dashboard through a polling status indicator. Results are guarded by both
-an in-memory dataframe limit and a serialized Dash-payload limit. Large-result
-warnings are logged before execution; oversized results are rejected with an
-actionable message asking you to reduce the sweep.
+the dashboard with visible queued, running, completed, and error messages beside
+Run. The completed-run card shows the number of result rows. Oversized sweeps are
+rejected with guidance when you click Run. Results are guarded by both an
+in-memory dataframe limit and a serialized Dash-payload limit, with estimated
+size validation before execution and actual size checks after computation.
 
 Run the command-line launcher with ``--debug`` to enable detailed logs. Log
 messages use the format ``timestamp | level | logger | message`` and include

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/assets/dashboard.css

@@ -2952,6 +2952,23 @@ button.material-name-select:focus-visible {
     color: var(--error);
 }
 
+.status-banner.warning {
+    background: rgba(210, 145, 20, 0.14);
+    color: var(--ink);
+}
+
+.experiment-run-feedback {
+    display: grid;
+    gap: 8px;
+}
+
+.experiment-run-feedback .status-banner {
+    position: static;
+    margin: 0;
+    font-size: 0.9rem;
+    overflow-wrap: anywhere;
+}
+
 .summary-grid {
     display: grid;
     grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/callback_helpers.py

@@ -14,7 +14,7 @@ from PyMieSimX.gui.models import ExperimentResult, MessageLevel, SingleResult
 from PyMieSimX.gui.services import ExperimentValidationError, build_single_figure, run_experiment
 
 
-_STATUS_ICONS = {"idle": "\u25cb", "success": "\u2713", "error": "\u26a0"}
+_STATUS_ICONS = {"idle": "\u25cb", "success": "\u2713", "warning": "\u26a0", "error": "\u26a0"}
 
 
 def status_banner(level: str, message: str):
@@ -65,7 +65,7 @@ def execute_experiment_callback(
     detector_type: str,
     detector_values: list[str],
     detector_ids: list[dict[str, str]],
-    measure: str,
+    measure: str | list[str],
     run_count: int | None,
 ) -> CallbackExecution:
     """Execute a parameter sweep and convert errors into UI-ready state."""

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/callbacks.py

@@ -23,8 +23,10 @@ from PyMieSimX.gui.callback_helpers import (
     execute_single_callback,
     merge_local_plot_values as _merge_local_plot_values,
     pair_ids_with_values as _pair_ids_with_values,
+    status_banner,
 )
 from PyMieSimX.gui.jobs import experiment_jobs
+from PyMieSimX.gui.validation import normalize_measures
 from PyMieSimX.gui import usage_metrics
 from PyMieSimX.gui.admin import build_admin_page, collect_admin_dashboard_data, dashboard_values, is_admin_access_granted
 from PyMieSimX.gui.services import (
@@ -417,7 +419,7 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Input("detector-type", "value"),
         State("measure-select", "value"),
     )
-    def _update_measure_options(scatterer_type: str, detector_type: str, current_measure: str | None):
+    def _update_measure_options(scatterer_type: str, detector_type: str, current_measure: str | list[str] | None):
         LOGGER.debug(
             "Updating measure options for scatterer=%s detector=%s current=%s",
             scatterer_type,
@@ -426,7 +428,9 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         )
         measures = available_measures(scatterer_type, detector_type)
         options = [{"label": measure, "value": measure} for measure in measures]
-        value = current_measure if current_measure in measures else measures[0]
+        value = [name for name in normalize_measures(current_measure) if name in measures]
+        if not value and current_measure != []:
+            value = measures[:1]
         alert_style = {} if detector_type == "None" else {"display": "none"}
         return options, value, alert_style
 
@@ -481,6 +485,7 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Output("experiment-job", "data"),
         Output("experiment-job-poll", "disabled", allow_duplicate=True),
         Output("run-experiment-button", "disabled", allow_duplicate=True),
+        Output("experiment-run-status", "children", allow_duplicate=True),
         Input("run-experiment-button", "n_clicks"),
         State("source-type", "value"),
         State({"kind": "field", "section": "source", "name": ALL}, "value"),
@@ -506,12 +511,12 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         detector_type: str,
         detector_values: list[str],
         detector_ids: list[dict[str, str]],
-        measure: str,
+        measure: str | list[str],
         previous_job: dict | None,
     ):
         # Dynamic page insertion can invoke callbacks without a button click.
         if not _run_clicks:
-            return no_update, no_update, no_update
+            return no_update, no_update, no_update, no_update
 
         LOGGER.debug(
             "Preparing background parameter sweep source=%s scatterer=%s detector=%s measure=%s",
@@ -534,9 +539,9 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
             measure=measure,
         )
         if issues:
-            message = " ".join(issue.message for issue in issues)
+            message = " ".join(f"{issue.field}: {issue.message}" for issue in issues)
             LOGGER.info("Experiment submission rejected: %s", message)
-            return None, True, False
+            return None, True, False, status_banner("error", f"Cannot run: {message}")
 
         if previous_job:
             experiment_jobs.cancel(previous_job.get("job_id"))
@@ -547,24 +552,30 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
             scatterer_values=scatterer_mapping,
             detector_type=detector_type,
             detector_values=detector_mapping,
-        )
-        job_id = experiment_jobs.submit(
-            source_type=source_type,
-            source_values=source_mapping,
-            scatterer_type=scatterer_type,
-            scatterer_values=scatterer_mapping,
-            detector_type=detector_type,
-            detector_values=detector_mapping,
             measure=measure,
         )
+        try:
+            job_id = experiment_jobs.submit(
+                source_type=source_type,
+                source_values=source_mapping,
+                scatterer_type=scatterer_type,
+                scatterer_values=scatterer_mapping,
+                detector_type=detector_type,
+                detector_values=detector_mapping,
+                measure=measure,
+            )
+        except Exception as error:  # noqa: BLE001 - submission failures must reach the user
+            LOGGER.exception("Failed to queue experiment")
+            return None, True, False, status_banner("error", f"Could not start the sweep: {error}. Click Run to retry.")
         LOGGER.info("Experiment queued job_id=%s rows_estimate=%d bytes_estimate=%d", job_id, estimate.rows, estimate.estimated_bytes)
-        return {"job_id": job_id}, False, True
+        return {"job_id": job_id}, False, True, status_banner("idle", "Queued. Waiting for a computation worker…")
 
     @app.callback(
         Output("experiment-result", "data"),
         Output("experiment-run-count", "data"),
         Output("experiment-job-poll", "disabled"),
         Output("run-experiment-button", "disabled"),
+        Output("experiment-run-status", "children"),
         Input("experiment-job-poll", "n_intervals"),
         State("experiment-job", "data"),
         State("experiment-run-count", "data"),
@@ -573,20 +584,24 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
     def _poll_experiment_job(_n_intervals: int, job_data: dict | None, experiment_runs: int):
         snapshot = experiment_jobs.snapshot((job_data or {}).get("job_id"))
         if snapshot is None:
-            return no_update, no_update, True, False
+            message = status_banner("error", "Run interrupted: the background job is no longer available. Click Run to retry.") if job_data else no_update
+            return no_update, no_update, True, False, message
         status = snapshot["status"]
         LOGGER.debug("Polling experiment job_id=%s status=%s", snapshot["job_id"], status)
         if status in {"pending", "running"}:
-            return no_update, no_update, False, no_update
+            message = "Queued. Waiting for a computation worker…" if status == "pending" else "Running. Computing your parameter sweep…"
+            return no_update, no_update, False, True, status_banner("idle", message)
         if status == "succeeded":
             result = snapshot["result"]
             try:
                 usage_metrics.record_experiment_run()
             except Exception:
                 LOGGER.exception("Failed to record PyMieSimX experiment-run metric.")
-            return result, int(experiment_runs or 0) + 1, True, False
+            return result, int(experiment_runs or 0) + 1, True, False, status_banner("success", f"Completed. {result['row_count']:,} result rows.")
+        if status == "cancelled":
+            return no_update, no_update, True, False, status_banner("warning", "Run cancelled. Click Run to start another sweep.")
         LOGGER.warning("Experiment job failed job_id=%s error=%s", snapshot["job_id"], snapshot["error"])
-        return no_update, no_update, True, False
+        return no_update, no_update, True, False, status_banner("error", f"Run failed: {snapshot['error'] or 'An unexpected computation error occurred.'}")
 
     @app.callback(
         Output("csv-download", "data"),
@@ -595,7 +610,7 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         State("measure-select", "value"),
         prevent_initial_call=True,
     )
-    def _export_csv(n_clicks: int, result: dict | None, measure: str | None):
+    def _export_csv(n_clicks: int, result: dict | None, measure: str | list[str] | None):
         LOGGER.debug("CSV export requested for measure=%s", measure)
 
         if not n_clicks:
@@ -608,7 +623,8 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
             LOGGER.debug("No CSV exported because result content is empty")
             return no_update
 
-        filename = f"pymiesim_{measure or 'result'}.csv"
+        exported_measures = (result or {}).get("measures") or [(result or {}).get("measure", "result")]
+        filename = f"pymiesim_{'_'.join(exported_measures)}.csv"
         LOGGER.debug("CSV export generated filename=%s", filename)
         return dcc.send_string(csv_content, filename)
 
@@ -661,7 +677,7 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Output("single-result", "data"),
         Output("single-run-count", "data"),
         Input("run-single-button", "n_clicks"),
-        Input("single-projection", "value"),
+        State("single-projection", "value"),
         State("single-source-type", "value"),
         State({"kind": "field", "section": "single-source", "name": ALL}, "value"),
         State({"kind": "field", "section": "single-source", "name": ALL}, "id"),
@@ -673,6 +689,11 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         State("single-nearfield-mode", "value"),
         State("single-include-incident-field", "value"),
         State("single-run-count", "data"),
+        prevent_initial_call=True,
+        running=[
+            (Output("single-graph-loading", "display"), "show", "auto"),
+            (Output("run-single-button", "disabled"), True, False),
+        ],
     )
     def _run_single(
         _run_clicks: int,
@@ -689,6 +710,9 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         include_incident_field: list[str] | None,
         single_runs: int,
     ):
+        if not _run_clicks:
+            return no_update, no_update
+
         execution = execute_single_callback(
             source_type=source_type,
             source_values=source_values,
@@ -712,6 +736,13 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
             LOGGER.exception("Failed to record PyMieSimX particle-explorer metric.")
         return execution.result, execution.run_count
 
+    @app.callback(
+        Output("result-graph-loading", "display"),
+        Input("run-experiment-button", "disabled"),
+    )
+    def _show_experiment_computing(run_disabled: bool):
+        return "show" if run_disabled else "auto"
+
     @app.callback(
         Output("single-representation", "options"),
         Output("single-representation", "value"),

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/computation.py

@@ -336,7 +336,8 @@ def build_single_figure(
         colorscale = PYMIESIM_BLUE_BLACK_RED
         x = np.asarray(nearfields.u.to(ureg.nanometer).magnitude, dtype=float)
         y = np.asarray(nearfields.v.to(ureg.nanometer).magnitude, dtype=float)
-        heatmap_kwargs = {"x": x, "y": y, "z": values, "colorscale": colorscale, "colorbar": {"title": "V/m"}}
+        # PyMieSim indexes fields as (u, v); Plotly indexes z as (y, x).
+        heatmap_kwargs = {"x": x, "y": y, "z": values.T, "colorscale": colorscale, "colorbar": {"title": "V/m"}}
         if not is_absolute:
             maximum = float(np.max(np.abs(values)))
             maximum = maximum if maximum > 0 else 1.0
@@ -459,6 +460,12 @@ def infer_variable_fields(
     return variable_fields
 
 
+def normalize_measures(measure: str | list[str] | None) -> list[str]:
+    """Accept legacy single-measure input and preserve unique selection order."""
+    values = [measure] if isinstance(measure, str) else (measure or [])
+    return list(dict.fromkeys(values))
+
+
 def run_experiment(
     *,
     source_type: str,
@@ -467,7 +474,7 @@ def run_experiment(
     scatterer_values: Dict[str, Any],
     detector_type: str,
     detector_values: Dict[str, Any],
-    measure: str,
+    measure: str | list[str],
 ) -> ExperimentResult:
     """Execute the selected experiment and serialize the result for Dash."""
     LOGGER.debug(
@@ -505,7 +512,8 @@ def run_experiment(
 
     LOGGER.debug("Experiment setup instantiated: %r", setup)
 
-    dataframe = setup.get(measure, drop_unique_level=True)
+    measures = normalize_measures(measure)
+    dataframe = setup.get(*measures, drop_unique_level=True)
     LOGGER.debug("Experiment returned dataframe with shape %s", getattr(dataframe, "shape", None))
     if hasattr(dataframe, "as_dataframe"):
         # Native LabeledArray results: convert and drop the "section:" column prefixes
@@ -529,10 +537,11 @@ def run_experiment(
     for column in frame.columns:
         frame[column] = frame[column].map(serialize_value)
 
-    parameter_columns = [column for column in frame.columns if column != measure]
+    parameter_columns = [column for column in frame.columns if column not in measures]
 
     result: ExperimentResult = {
-        "measure": measure,
+        "measure": measures[0],
+        "measures": measures,
         "units": units,
         "columns": [str(column) for column in frame.columns],
         "parameter_columns": parameter_columns,
@@ -591,6 +600,7 @@ def estimate_result_size(
     scatterer_values: Dict[str, Any],
     detector_type: str,
     detector_values: Dict[str, Any],
+    measure: str | list[str] | None = None,
 ) -> ResultSizeEstimate:
     """Estimate serialized result size before starting a computation."""
     row_count = estimate_sweep_size(
@@ -601,7 +611,7 @@ def estimate_result_size(
         detector_type=detector_type,
         detector_values=detector_values,
     )
-    column_count = 1 + sum(
+    column_count = max(1, len(normalize_measures(measure))) + sum(
         len(field_groups.get(selected_type, ()))
         for field_groups, selected_type in (
             ((SOURCE_FIELDS, source_type), (SCATTERER_FIELDS, scatterer_type), (DETECTOR_FIELDS, detector_type))
@@ -627,7 +637,7 @@ def validate_experiment_inputs(
     scatterer_values: Dict[str, Any],
     detector_type: str,
     detector_values: Dict[str, Any],
-    measure: str,
+    measure: str | list[str] | None,
 ) -> list[ValidationIssue]:
     """Validate all experiment fields and return actionable user-facing issues."""
     issues: list[ValidationIssue] = []
@@ -659,10 +669,14 @@ def validate_experiment_inputs(
             except (TypeError, ValueError, KeyError) as error:
                 issues.append(ValidationIssue(field.name, str(error)))
 
+    measures = normalize_measures(measure)
+    if not measures:
+        issues.append(ValidationIssue("measure", "Select at least one measure."))
     if scatterer_type in SCATTERER_TYPES and detector_type in DETECTOR_TYPES:
         valid_measures = available_measures(scatterer_type, detector_type)
-        if measure not in valid_measures:
-            issues.append(ValidationIssue("measure", f"'{measure}' is not available for this configuration."))
+        for selected_measure in measures:
+            if selected_measure not in valid_measures:
+                issues.append(ValidationIssue("measure", f"'{selected_measure}' is not available for this configuration."))
 
     if not issues:
         sweep_size = estimate_sweep_size(
@@ -688,6 +702,7 @@ def validate_experiment_inputs(
                 scatterer_values=scatterer_values,
                 detector_type=detector_type,
                 detector_values=detector_values,
+                measure=measures,
             )
             if result_estimate.estimated_bytes > MAX_RESULT_PAYLOAD_BYTES:
                 issues.append(
@@ -769,11 +784,17 @@ def build_figure(result: dict[str, Any] | None, x_axis: str | None, plot_setting
         apply_plot_settings(figure, plot_settings, theme)
         return figure
 
+    measures = result.get("measures") or [result["measure"]]
+    if len(measures) > 1:
+        return _build_multi_measure_figure(result, x_axis, plot_settings, theme, projection)
+
     frame = pd.DataFrame(result["rows"])
     measure = result["measure"]
     parameter_columns = result["parameter_columns"]
     units = result.get("units", {})
     LOGGER.debug("Figure frame columns=%s row_count=%d", list(frame.columns), len(frame))
+    extra_axes = []
+    use_polar = False
 
     if not parameter_columns:
         resolved_x_axis = "index"
@@ -805,7 +826,8 @@ def build_figure(result: dict[str, Any] | None, x_axis: str | None, plot_setting
             plot_kwargs["color"] = series_column
             plot_kwargs["line_group"] = series_column
 
-        if projection == "polar" and _is_angular_unit(xaxis_unit):
+        use_polar = (projection == "polar" or (plot_settings or {}).get("coordinate_system") == "polar") and _is_angular_unit(xaxis_unit)
+        if use_polar:
             figure = go.Figure()
             groups = frame.groupby(series_column, sort=False) if extra_axes else [(measure, frame)]
             for series_name, group in groups:
@@ -835,8 +857,8 @@ def build_figure(result: dict[str, Any] | None, x_axis: str | None, plot_setting
         plot_bgcolor="white",
         margin={"l": 40, "r": 20, "t": 50, "b": 40},
         title=f"{measure} response",
-        xaxis_title=None if projection == "polar" and _is_angular_unit(xaxis_unit) else xaxis_title,
-        yaxis_title=None if projection == "polar" and _is_angular_unit(xaxis_unit) else yaxis_title,
+        xaxis_title=None if use_polar else xaxis_title,
+        yaxis_title=None if use_polar else yaxis_title,
         legend_title_text="",
         meta={
             "polar_axis_unit": xaxis_unit,
@@ -848,6 +870,61 @@ def build_figure(result: dict[str, Any] | None, x_axis: str | None, plot_setting
     return figure
 
 
+def _build_multi_measure_figure(result, x_axis, plot_settings, theme, projection) -> go.Figure:
+    """Overlay comparable measures and give different units their own axes."""
+    from plotly.subplots import make_subplots
+
+    measures = result["measures"]
+    units = result.get("units", {})
+    groups: dict[str, list[str]] = {}
+    figures = {}
+    for measure in measures:
+        groups.setdefault(units.get(measure, ""), []).append(measure)
+        figures[measure] = build_figure(
+            {**result, "measure": measure, "measures": [measure]},
+            x_axis, plot_settings, theme, projection,
+        )
+    first = figures[measures[0]]
+    is_polar = bool(first.data and first.data[0].type == "scatterpolar")
+    row_count = len(groups)
+    figure = make_subplots(
+        rows=row_count, cols=1, shared_xaxes=not is_polar,
+        specs=[[{"type": "polar" if is_polar else "xy"}] for _ in groups],
+        subplot_titles=[", ".join(names) for names in groups.values()],
+        vertical_spacing=min(0.08, 0.5 / row_count),
+    )
+    for row, (unit, names) in enumerate(groups.items(), start=1):
+        for measure in names:
+            color = px.colors.qualitative.Plotly[measures.index(measure) % len(px.colors.qualitative.Plotly)]
+            for series_index, trace in enumerate(figures[measure].data):
+                trace.name = measure if not trace.name or trace.name == measure else f"{measure} | {trace.name}"
+                trace.legendgroup = measure
+                trace.showlegend = True
+                if getattr(trace, "line", None) is not None:
+                    trace.line.color = color
+                    if "dash" in trace.line._valid_props:
+                        trace.line.dash = ("solid", "dash", "dot", "dashdot", "longdash", "longdashdot")[series_index % 6]
+                if getattr(trace, "marker", None) is not None:
+                    trace.marker.color = color
+                figure.add_trace(trace, row=row, col=1)
+        if is_polar:
+            key = "polar" if row == 1 else f"polar{row}"
+            figure.update_layout({key: figures[names[0]].layout.polar.to_plotly_json()})
+        else:
+            display_unit = {"dimensionless": "", "meter ** 2": "m²", "watt": "W"}.get(unit, unit)
+            title = f"Value [{display_unit}]" if display_unit else "Value"
+            figure.update_yaxes(title_text=title, row=row, col=1)
+    figure.update_layout(meta={**(first.layout.meta or {}), "measures": measures}, barmode="group")
+    apply_plot_settings(figure, plot_settings, theme, polar_allowed=False)
+    settings = {**DEFAULT_PLOT_SETTINGS, **(plot_settings or {})}
+    if not is_polar:
+        figure.update_xaxes(showgrid=bool(settings["show_grid"]), type=settings["x_scale"])
+        figure.update_yaxes(showgrid=bool(settings["show_grid"]), type="log" if settings["log_y"] else "linear")
+        figure.update_xaxes(title_text=first.layout.xaxis.title.text, row=row_count, col=1)
+    figure.update_layout(height=max(int(settings["graph_height"]), 300 * row_count + 125))
+    return figure
+
+
 def _resolve_x_axis(x_axis: str | None, parameter_columns: list[str]) -> str:
     """Resolve a selector field name against namespaced result columns."""
     if x_axis in parameter_columns:
@@ -1010,7 +1087,7 @@ def build_summary(result: dict[str, Any] | None) -> list[dict[str, str]]:
     LOGGER.debug("Building summary cards for measure=%s", result["measure"])
 
     return [
-        {"label": "Measure", "value": result["measure"]},
+        {"label": "Measures", "value": ", ".join(result.get("measures") or [result["measure"]])},
         {"label": "Rows", "value": str(result["row_count"])},
         {"label": "Axes", "value": ", ".join(result["parameter_columns"]) or "none"},
     ]

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/layout.py

@@ -188,13 +188,14 @@ def _x_axis_card(default_measure_options: list[str]):
                     html.Div(
                         className="graph-axis-field",
                         children=[
-                            html.Label("Y axis", htmlFor="measure-select"),
+                            html.Label("Measures", htmlFor="measure-select"),
                             dcc.Dropdown(
                                 id="measure-select",
                                 className="dashboard-dropdown graph-axis-control",
                                 options=[{"label": measure, "value": measure} for measure in default_measure_options],
-                                value=default_measure_options[0] if default_measure_options else None,
-                                clearable=False,
+                                value=[default_measure_options[0]] if default_measure_options else [],
+                                multi=True,
+                                clearable=True,
                                 searchable=False,
                                 optionHeight=38,
                                 maxHeight=200,

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/models.py

@@ -1,7 +1,7 @@
 """Typed data contracts shared by the computation and Dash layers."""
 
 from dataclasses import dataclass
-from typing import Any, Literal, Mapping, TypedDict
+from typing import Any, Literal, Mapping, NotRequired, TypedDict
 
 
 FieldValues = Mapping[str, Any]
@@ -16,6 +16,7 @@ class ExperimentResult(TypedDict):
     columns: list[str]
     parameter_columns: list[str]
     measure: str
+    measures: NotRequired[list[str]]
     units: dict[str, str]
     row_count: int
 
@@ -49,7 +50,7 @@ class ExperimentRequest:
     scatterer_values: FieldValues
     detector_type: str
     detector_values: FieldValues
-    measure: str
+    measure: str | list[str]
 
     def as_kwargs(self) -> dict[str, Any]:
         """Return keyword arguments accepted by the compatibility API."""

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/pages/experiment/page.py

@@ -3,6 +3,7 @@
 
 from dash import dcc, html
 
+from PyMieSimX.gui.callback_helpers import status_banner
 from PyMieSimX.gui.layout import PLOT_CONFIG, _plot_options_card, _x_axis_card, build_plot_options_sidebar, build_tabbed_sidebar
 
 from .sections import build_detector_section, build_scatterer_section, build_source_section
@@ -43,6 +44,11 @@ def build_experiment_page(default_measure_options: list[str], plot_settings: dic
                                     ),
                                 ],
                             ),
+                            html.Div(
+                                id="experiment-run-status",
+                                className="experiment-run-feedback",
+                                children=status_banner("idle", "Ready. Click Run to start a sweep."),
+                            ),
                             html.Section(className="panel graph-panel", children=[dcc.Loading(id="result-graph-loading", type="circle", color="#4f8df7", custom_spinner=html.Div("Computing…", className="plot-computing-indicator"), delay_show=150, delay_hide=150, children=dcc.Graph(id="result-graph", config=PLOT_CONFIG))]),
                         ],
                     ),

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX/gui/validation.py

@@ -12,6 +12,7 @@ from PyMieSimX.gui.computation import (
     _value_cardinality,
     estimate_result_size,
     estimate_sweep_size,
+    normalize_measures,
     validate_experiment_inputs,
 )
 

{pymiesimx-0.1.3 → pymiesimx-0.1.5}/PyMieSimX.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMieSimX
-Version: 0.1.3
+Version: 0.1.5
 Summary: Graphical Dash interface for PyMieSim.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License-Expression: MIT
@@ -112,14 +112,30 @@ The computational API can be used without constructing the Dash application::
 ``PyMieSimX.create_dash_app`` and ``PyMieSimX.OpticalSetupGUI`` remain
 available for applications that need the graphical interface.
 
+Multiple measures
+-----------------
+
+The Parameter Sweep Measures selector accepts several quantities in one run.
+For example, select ``Qsca``, ``Qabs``, and ``Qext`` to compare scattering,
+absorption, and extinction efficiencies. Measures with the same units share a
+plot; different units use separate panels with a shared X axis. CSV exports
+contain a column for each computed measure.
+
+The Python API accepts either a single name or a list, for example
+``run_experiment(..., measure=["Qsca", "Qabs", "Qext"])``. Results include
+``measures`` with every computed name; ``measure`` retains the first name for
+compatibility with existing single-measure callers. Size validation accounts
+for the additional result columns.
+
 Background calculations and limits
 -----------------------------------
 
 Parameter sweeps are submitted to a bounded background worker and reported to
-the dashboard through a polling status indicator. Results are guarded by both
-an in-memory dataframe limit and a serialized Dash-payload limit. Large-result
-warnings are logged before execution; oversized results are rejected with an
-actionable message asking you to reduce the sweep.
+the dashboard with visible queued, running, completed, and error messages beside
+Run. The completed-run card shows the number of result rows. Oversized sweeps are
+rejected with guidance when you click Run. Results are guarded by both an
+in-memory dataframe limit and a serialized Dash-payload limit, with estimated
+size validation before execution and actual size checks after computation.
 
 Run the command-line launcher with ``--debug`` to enable detailed logs. Log
 messages use the format ``timestamp | level | logger | message`` and include

pymiesimx-0.1.5/PyMieSimX.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.5",
+  "distance": 0,
+  "node": "gd609c6cff7e32e562d54244f48e9fe337e64b543",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-02"
+}