PyMieSimX 0.2.0__tar.gz → 0.2.2__tar.gz

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMieSimX
-Version: 0.2.0
+Version: 0.2.2
 Summary: Graphical Dash interface for PyMieSim.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License-Expression: MIT
@@ -50,6 +50,21 @@ optical setups, run parameter sweeps, explore individual particles, and download
 your results as CSV files. The hosted service provides direct access to the
 graphical interface; local installation is also available below.
 
+Sharing simulations
+-------------------
+
+Use **Copy simulation link** in Single Scatterer, Parameter Scan, or Ensemble
+Optics to share the current setup. Links preserve the input values, sweep
+ranges, selected measures, and plot settings without requiring an account.
+Opening a link restores the setup and automatically runs the simulation once
+the inputs and plot settings are ready. Later edits can be calculated with
+**Run**. If clipboard access is unavailable, use **Show simulation
+link** and copy the displayed URL.
+
+Links store the configuration rather than a result snapshot. Recalculation
+uses the installed solver and optical material data, so results can change
+after those dependencies are updated.
+
 Ensemble Optics
 ---------------
 

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PyMieSimX/gui/assets/dashboard.css

@@ -499,9 +499,9 @@ html .home-metric-tile { font-size: .92rem !important; }
 .version-widget-label { font-size: .72rem; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; opacity: .7; }
 .version-widget-value { font-size: .92rem; font-weight: 700; }
 
-html .home-page-hero { padding: 26px !important; border-radius: 15px; border-left: 5px solid rgba(13, 110, 253, .75); }
-html .home-page-hero h1 { margin: 0 0 8px; font-family: inherit !important; font-size: 2.55rem !important; font-weight: 800; line-height: 1.05; }
-html .home-page-hero .hero-text { max-width: 980px; margin: 0; font-size: 1.08rem !important; line-height: normal; opacity: .86; }
+html .home-page-hero { padding: 30px !important; border-radius: 15px; border-left: 5px solid rgba(13, 110, 253, .75); }
+html .home-page-hero h1 { margin: 0 0 12px; letter-spacing: -.045em; font-family: inherit !important; font-size: 2.55rem !important; font-weight: 800; line-height: 1.05; }
+html .home-page-hero .hero-text { max-width: 460px; margin: 0; font-size: 1rem !important; line-height: 1.6; opacity: .7; }
 
 html .home-metrics-card > .card-body {
     display: grid;
@@ -3869,76 +3869,85 @@ html .single-workspace .representation-card {
     display: flex;
     align-items: center;
     justify-content: space-between;
-    gap: 24px;
+    gap: 28px;
     flex-wrap: wrap;
 }
 
 .home-hero-copy {
-    flex: 1 1 360px;
+    flex: 1 1 300px;
     min-width: 0;
 }
 
 .home-hero-actions {
     display: flex;
     align-items: center;
-    justify-content: flex-end;
     flex-wrap: wrap;
-    gap: 14px;
+    gap: 26px;
     margin-left: auto;
 }
 
 .home-visit-metric {
     display: flex;
     flex-direction: column;
-    align-items: center;
-    gap: 3px;
-    padding: 9px 16px;
-    border: 1px solid #cddcec;
-    border-radius: 9px;
-    background: #f3f7fc;
-    color: #2f4358;
-}
-
-.home-visit-label {
-    font-size: .72rem;
-    font-weight: 600;
+    gap: 4px;
+    padding-right: 26px;
+    border-right: 1px solid #e5e7eb;
 }
 
 .home-visit-value {
-    font-size: 1.2rem;
+    font-size: 1.9rem;
+    font-weight: 750;
     line-height: 1.2;
+    letter-spacing: -.04em;
     font-variant-numeric: tabular-nums;
 }
 
+.home-visit-label {
+    font-size: .75rem;
+    opacity: .6;
+}
+
 .home-support-actions {
     display: flex;
     flex-direction: column;
-    gap: 9px;
+    gap: 8px;
 }
 
 .home-support-button {
     display: inline-flex;
     align-items: center;
-    gap: 9px;
-    flex: 0 0 auto;
-    padding: 10px 17px;
-    border: 1px solid #e8c56b;
-    border-radius: 9px;
-    background: linear-gradient(135deg, #fff8e3, #ffe8a9);
-    color: #704912;
-    font-size: .92rem;
-    font-weight: 700;
+    gap: 10px;
+    min-height: 42px;
+    padding: 8px 13px;
+    border: 1px solid #e8d6ad;
+    border-radius: 10px;
+    background: #fcf5e7;
+    color: #795520;
+    font-size: .82rem;
+    font-weight: 650;
+    line-height: 1.4;
     text-decoration: none;
-    white-space: nowrap;
-    box-shadow: 0 3px 9px rgba(151, 104, 23, .10);
-    transition: background 150ms ease, box-shadow 150ms ease;
+    transition: background 150ms ease, border-color 150ms ease, box-shadow 150ms ease;
 }
 
 .home-support-button:hover {
-    background: #ffe49a;
-    color: #58350b;
+    background: #f8ecd2;
+    border-color: #d7bd85;
+    color: #674516;
     text-decoration: none;
-    box-shadow: 0 4px 12px rgba(151, 104, 23, .18);
+    box-shadow: 0 2px 6px rgba(112, 79, 25, .08);
+}
+
+.home-star-button {
+    background: #fff;
+    border-color: #e5e7eb;
+    color: #343b46;
+}
+
+.home-star-button:hover {
+    background: #f5f6f8;
+    border-color: #cbd0d8;
+    color: #343b46;
 }
 
 .home-support-button:focus-visible {
@@ -3947,8 +3956,47 @@ html .single-workspace .representation-card {
 }
 
 .home-support-icon {
-    color: #ad6515;
-    font-size: 1.1rem;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 22px;
+    font-size: 1.15rem;
+    line-height: 1;
+}
+
+.home-support-label {
+    flex: 1;
+}
+
+.home-support-arrow {
+    font-size: 1rem;
+    opacity: .45;
+}
+
+@media (max-width: 575px) {
+    html .home-page-hero {
+        padding: 22px !important;
+        gap: 22px;
+    }
+
+    .home-hero-actions {
+        justify-content: space-between;
+        width: 100%;
+        margin-left: 0;
+        gap: 18px;
+    }
+
+    .home-visit-metric {
+        border-right: 0;
+        padding-right: 0;
+        flex-direction: row;
+        align-items: baseline;
+        gap: 10px;
+    }
+
+    .home-support-actions {
+        width: 100%;
+    }
 }
 
 .admin-page {
@@ -4007,3 +4055,31 @@ html .single-workspace .representation-card {
 .population-page .documentation-table td { overflow-wrap: anywhere; }
 #population-status, #population-preview-error { margin-bottom: 12px; }
 #population-results { overflow-x: auto; }
+.workspace-intro {
+    margin: 0;
+    color: var(--muted);
+    font-size: .86rem;
+    line-height: 1.6;
+}
+
+.single-tab-content, .experiment-tab-content, .population-page { gap: 12px; }
+.page-hero.workspace-header {
+    box-sizing: border-box;
+    min-height: 76px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    gap: 4px;
+}
+.workspace-header .hero-text { max-width: none; line-height: 1.6; min-height: 2lh; }
+@media (max-width: 700px) {
+    .page-hero.workspace-header { min-height: 148px; }
+    .workspace-header .eyebrow { min-height: 2lh; }
+    .workspace-header .hero-text { min-height: 4lh; }
+}
+
+.simulation-share-feedback { display: grid; gap: 8px; font-size: .86rem; color: var(--muted); }
+.simulation-share-actions { display: contents; }
+.simulation-share-feedback:empty { display: none; }
+.simulation-share-feedback .field-input { width: 100%; min-width: 0; }
+.simulation-link-notice { padding: 10px 14px; border: 1px solid var(--line); border-radius: 8px; color: var(--ink); }

pymiesimx-0.2.2/PyMieSimX/gui/assets/simulation-sharing.js

@@ -0,0 +1,36 @@
+window.dash_clientside = Object.assign({}, window.dash_clientside, {
+    simulation_sharing: {
+        auto_run: function(config, fieldIds, fieldValues, fieldClasses, settings) {
+            const unchanged = window.dash_clientside.no_update;
+            if (!config || config.started) return [unchanged, unchanged];
+            const values = Array.prototype.slice.call(arguments, 5);
+            const clicks = values.pop();
+            if (clicks) return [unchanged, Object.assign({}, config, {started: true})];
+
+            const actual = {};
+            config.control_names.forEach((name, index) => { actual[name] = values[index]; });
+            (fieldIds || []).forEach((id, index) => {
+                const ordered = {};
+                Object.keys(id).sort().forEach(key => { ordered[key] = id[key]; });
+                actual[JSON.stringify(ordered)] = fieldValues[index];
+            });
+            // Field classes depend on the existing validation callbacks; this
+            // also waits for dynamic fields and material-mode restoration.
+            if (!fieldClasses || fieldClasses.length < config.field_keys.length ||
+                !config.field_keys.every(key => Object.prototype.hasOwnProperty.call(actual, key))) {
+                return [unchanged, unchanged];
+            }
+            const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+            if (!Object.entries(config.expected_controls).every(([key, value]) => same(actual[key], value))) {
+                return [unchanged, unchanged];
+            }
+            const plot = (settings || {})[config.workspace] || {};
+            if (!Object.entries(config.plot_settings).every(([key, value]) => same(plot[key], value))) {
+                return [unchanged, unchanged];
+            }
+            // Both outputs update together. Later edits and callback updates
+            // see the started flag and cannot launch a second automatic run.
+            return [1, Object.assign({}, config, {started: true})];
+        }
+    }
+});

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PyMieSimX/gui/callbacks.py

@@ -31,6 +31,7 @@ from PyMieSimX.gui.callback_helpers import (
 from PyMieSimX.gui.jobs import experiment_jobs
 from PyMieSimX.gui.validation import normalize_measures
 from PyMieSimX.gui import usage_metrics
+from PyMieSimX.gui.sharing import register_sharing_callbacks, read_simulation, shared_setup, shared_plot_settings, restore_controls
 from PyMieSimX.gui.admin import build_admin_page, collect_admin_dashboard_data, dashboard_values, is_admin_access_granted
 from PyMieSimX.gui.services import (
     available_measures,
@@ -194,6 +195,21 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
     def _route_pages(pathname: str | None, search: str | None, home_visits: int, experiment_runs: int, single_runs: int, theme_store: dict | None, plot_settings: dict | None):
         """Render only the selected route page inside the persistent shell."""
         route = pathname or "/"
+        try:
+            setup = read_simulation(search, route)
+            share_message = "Shared setup loaded. This simulation runs automatically." if setup else None
+        except ValueError as error:
+            setup = None
+            share_message = str(error)
+        plot_settings = shared_plot_settings(plot_settings, setup)
+
+        def simulation_page(page):
+            from dash import html
+            restore_controls(page, setup)
+            if share_message:
+                page.children.insert(0, html.Div(share_message, role="status", className="simulation-link-notice"))
+            return build_page_with_footer(page)
+
         active = {
             "home": "sidebar-link",
             "experiment": "sidebar-link",
@@ -233,13 +249,13 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
             return build_page_with_footer(build_settings_page((theme_store or {}).get("theme", "light"), plot_settings or {})), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
         if route == "/single":
             active["single"] += " active"
-            return build_page_with_footer(build_single_page((plot_settings or {}).get("particle_explorer", {}))), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
+            return simulation_page(build_single_page((plot_settings or {}).get("particle_explorer", {}), setup)), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
         if route == "/population":
             active["population"] += " active"
-            return build_page_with_footer(build_population_page()), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
+            return simulation_page(build_population_page()), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
         if route == "/experiment":
             active["experiment"] += " active"
-            return build_page_with_footer(build_experiment_page(default_measure_options, plot_settings or {})), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
+            return simulation_page(build_experiment_page(default_measure_options, plot_settings or {}, setup)), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
         active["home"] += " active"
         return build_page_with_footer(build_home_page(home_visits=home_visits)), *(active[key] for key in ("home", "experiment", "single", "documentation", "settings", "population")), home_visits
 
@@ -292,9 +308,12 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Input("plot-experiment-legend", "value", allow_optional=True),
         Input("plot-experiment-grid", "value", allow_optional=True),
         State("plot-settings-store", "data"),
+        State("url", "search"),
+        State("url", "pathname"),
     )
     def _sync_plot_settings(*values):
-        stored_settings = values[-1] or {}
+        search, path = values[-2:]
+        stored_settings = shared_plot_settings(values[-3], shared_setup(search, path))
         particle_values = values[:9]
         sweep_values = values[9:18]
         single_local_values = values[18:24]
@@ -387,28 +406,43 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
 
         return classes, errors
 
-    @app.callback(Output("source-fields", "children"), Input("source-type", "value"))
-    def _render_source_fields(source_type: str):
+    @app.callback(Output("source-fields", "children"), Input("source-type", "value"), State("url", "search"))
+    def _render_source_fields(source_type: str, search: str = ""):
         LOGGER.debug("Rendering source fields for %s", source_type)
-        return render_fields("source", source_type)
+        setup = shared_setup(search, "/experiment")
+        if setup and setup["controls"].get("source-type") != source_type:
+            setup = None
+        return restore_controls(render_fields("source", source_type), setup)
 
-    @app.callback(Output("scatterer-fields", "children"), Input("scatterer-type", "value"))
-    def _render_scatterer_fields(scatterer_type: str):
+    @app.callback(Output("scatterer-fields", "children"), Input("scatterer-type", "value"), State("url", "search"))
+    def _render_scatterer_fields(scatterer_type: str, search: str = ""):
         LOGGER.debug("Rendering scatterer fields for %s", scatterer_type)
-        return render_fields("scatterer", scatterer_type)
+        setup = shared_setup(search, "/experiment")
+        if setup and setup["controls"].get("scatterer-type") != scatterer_type:
+            setup = None
+        return restore_controls(render_fields("scatterer", scatterer_type), setup)
 
-    @app.callback(Output("detector-fields", "children"), Input("detector-type", "value"))
-    def _render_detector_fields(detector_type: str):
+    @app.callback(Output("detector-fields", "children"), Input("detector-type", "value"), State("url", "search"))
+    def _render_detector_fields(detector_type: str, search: str = ""):
         LOGGER.debug("Rendering detector fields for %s", detector_type)
-        return render_fields("detector", detector_type)
-
-    @app.callback(Output("single-source-fields", "children"), Input("single-source-type", "value"))
-    def _render_single_source_fields(source_type: str):
-        return render_fields("single-source", source_type)
-
-    @app.callback(Output("single-scatterer-fields", "children"), Input("single-scatterer-type", "value"))
-    def _render_single_scatterer_fields(scatterer_type: str):
-        return render_fields("single-scatterer", scatterer_type)
+        setup = shared_setup(search, "/experiment")
+        if setup and setup["controls"].get("detector-type") != detector_type:
+            setup = None
+        return restore_controls(render_fields("detector", detector_type), setup)
+
+    @app.callback(Output("single-source-fields", "children"), Input("single-source-type", "value"), State("url", "search"))
+    def _render_single_source_fields(source_type: str, search: str = ""):
+        setup = shared_setup(search, "/single")
+        if setup and setup["controls"].get("single-source-type") != source_type:
+            setup = None
+        return restore_controls(render_fields("single-source", source_type), setup)
+
+    @app.callback(Output("single-scatterer-fields", "children"), Input("single-scatterer-type", "value"), State("url", "search"))
+    def _render_single_scatterer_fields(scatterer_type: str, search: str = ""):
+        setup = shared_setup(search, "/single")
+        if setup and setup["controls"].get("single-scatterer-type") != scatterer_type:
+            setup = None
+        return restore_controls(render_fields("single-scatterer", scatterer_type), setup)
 
     @app.callback(
         Output({"kind": "material-toggle", "section": MATCH, "name": MATCH}, "className"),
@@ -478,6 +512,7 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Input({"kind": "field", "section": "detector", "name": ALL}, "value"),
         Input({"kind": "field", "section": "detector", "name": ALL}, "id"),
         State("x-axis-select", "value"),
+        State("url", "search"),
     )
     def _update_x_axis_options(
         source_type: str,
@@ -490,6 +525,7 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         detector_values: list[str],
         detector_ids: list[dict[str, str]],
         current_x_axis: str | None,
+        search: str = "",
     ):
         LOGGER.debug(
             "Updating x-axis options from form state source=%s scatterer=%s detector=%s current=%s",
@@ -509,6 +545,16 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         )
 
         options = [{"label": field_name, "value": field_name} for field_name in variable_fields]
+        setup = shared_setup(search, "/experiment")
+        if setup:
+            desired_axis = setup["controls"].get("x-axis-select")
+            complete = (len(source_ids) == len(SOURCE_FIELDS[source_type])
+                        and len(scatterer_ids) == len(SCATTERER_FIELDS[scatterer_type])
+                        and len(detector_ids) == len(DETECTOR_FIELDS[detector_type]))
+            if current_x_axis is None or current_x_axis == desired_axis:
+                current_x_axis = desired_axis
+                if not complete:
+                    return options, current_x_axis
         value = current_x_axis if current_x_axis in variable_fields else (variable_fields[0] if variable_fields else None)
         return options, value
 
@@ -835,12 +881,25 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Input("single-representation", "value"),
         Input("single-projection", "value"),
         State("plot-settings-store", "data"),
+        State("url", "search"),
+        State("plot-single-x-scale", "value", allow_optional=True),
+        State("plot-single-y-scale", "value", allow_optional=True),
+        State("plot-single-font-size", "value", allow_optional=True),
+        State("plot-single-line-width", "value", allow_optional=True),
+        State("plot-single-legend", "value", allow_optional=True),
+        State("plot-single-grid", "value", allow_optional=True),
     )
-    def _update_single_plot_options(representation: str, projection: str, plot_settings: dict | None):
+    def _update_single_plot_options(representation: str, projection: str, plot_settings: dict | None, search: str = "", *local_values):
+        setup = shared_setup(search, "/single")
+        plot_settings = shared_plot_settings(plot_settings, setup)
         particle_settings = (plot_settings or {}).get("particle_explorer", plot_settings or {})
+        particle_settings = _merge_local_plot_values(particle_settings, local_values)
         from PyMieSimX.gui.layout import _plot_options_card
 
-        return _plot_options_card("single", particle_settings, representation, projection)
+        card = _plot_options_card("single", particle_settings, representation, projection)
+        if setup:
+            restore_controls(card, {**setup, "controls": {}})
+        return card
 
     @app.callback(
         Output("experiment-plot-options-container", "children"),
@@ -848,22 +907,38 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         Input("experiment-result", "data"),
         State("plot-settings-store", "data"),
         State("plot-experiment-projection", "value", allow_optional=True),
+        State("url", "search"),
+        State("plot-experiment-x-scale", "value", allow_optional=True),
+        State("plot-experiment-y-scale", "value", allow_optional=True),
+        State("plot-experiment-font-size", "value", allow_optional=True),
+        State("plot-experiment-line-width", "value", allow_optional=True),
+        State("plot-experiment-legend", "value", allow_optional=True),
+        State("plot-experiment-grid", "value", allow_optional=True),
     )
-    def _update_experiment_plot_options(x_axis: str | None, result: dict | None, plot_settings: dict | None, current_projection: str | None):
+    def _update_experiment_plot_options(x_axis: str | None, result: dict | None, plot_settings: dict | None, current_projection: str | None, search: str = "", *local_values):
+        setup = shared_setup(search, "/experiment")
+        plot_settings = shared_plot_settings(plot_settings, setup)
         sweep_settings = (plot_settings or {}).get("parameter_sweep", plot_settings or {})
         units = (result or {}).get("units", {})
         xaxis_unit = units.get(x_axis)
         if xaxis_unit is None and x_axis:
             matching_units = [value for key, value in units.items() if key.rsplit(":", 1)[-1] == x_axis]
             xaxis_unit = matching_units[0] if matching_units else None
+        if xaxis_unit is None and x_axis:
+            xaxis_unit = next((str(spec.unit) for group in (SOURCE_FIELDS, SCATTERER_FIELDS, DETECTOR_FIELDS)
+                              for specs in group.values() for spec in specs if spec.name == x_axis and spec.unit is not None), None)
         is_angle = _is_angular_unit(xaxis_unit)
         options = [{"label": "Cartesian", "value": "cartesian"}]
         if is_angle:
             options.append({"label": "Polar", "value": "polar"})
         projection = current_projection if is_angle and current_projection == "polar" else "cartesian"
+        sweep_settings = _merge_local_plot_values(sweep_settings, local_values)
         from PyMieSimX.gui.layout import _plot_options_card
 
-        return _plot_options_card("experiment", sweep_settings, projection=projection, projection_options=options)
+        card = _plot_options_card("experiment", sweep_settings, projection=projection, projection_options=options)
+        if setup:
+            restore_controls(card, {**setup, "controls": {}})
+        return card
 
     @app.callback(
         Output("single-graph", "figure"),
@@ -894,6 +969,8 @@ def register_callbacks(app: Dash, default_measure_options: list[str]) -> None:
         """Keep Export CSV greyed out until Run has produced a result."""
         return not result
 
+    register_sharing_callbacks(app)
+
 
 def build_single_empty_figure(plot_settings: dict | None = None, theme: str = "light"):
     """Return the initial representation canvas."""

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PyMieSimX/gui/components/cards.py

@@ -6,6 +6,14 @@ from collections.abc import Sequence
 from dash import html
 
 
+def workspace_header(title: str, description: str):
+    """Build the same compact introduction card for each simulation workspace."""
+    return html.Section(className="page-hero workspace-header", children=[
+        html.P(title, className="eyebrow"),
+        html.P(description, className="hero-text workspace-intro"),
+    ])
+
+
 class Card:
     """Build a RosettaX-style card with an optional colored left accent."""
 

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PyMieSimX/gui/interface.py

@@ -14,6 +14,7 @@ from PyMieSimX.gui.callbacks import register_callbacks
 from PyMieSimX.gui.layout import create_layout
 from PyMieSimX.gui.material_catalog import ensure_material_catalog
 from PyMieSimX.gui.services import available_measures
+from PyMieSimX.gui.seo import PAGE_METADATA, SearchDash, register_page_metadata
 
 LOGGER = logging.getLogger(__name__)
 GITHUB_RELEASES_URL = "https://github.com/MartinPdeS/PyMieSimX/releases"
@@ -36,9 +37,10 @@ def _initialize_material_catalog() -> None:
 
 def create_dash_app() -> Dash:
     """Create and configure the experiment dashboard Dash application."""
-    application = Dash(
+    application = SearchDash(
         __name__,
-        title="PyMieSim",
+        title=PAGE_METADATA["/"]["title"],
+        update_title=None,
         assets_folder=str(Path(__file__).with_name("assets")),
         suppress_callback_exceptions=True,
     )
@@ -51,6 +53,7 @@ def create_dash_app() -> Dash:
     initial_measures = available_measures("SphereSet", "PhotodiodeSet")
     application.layout = create_layout(initial_measures)
     register_callbacks(application, initial_measures)
+    register_page_metadata(application)
     LOGGER.debug("Dash application initialized with %d callbacks", len(application.callback_map))
     return application
 

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PyMieSimX/gui/layout.py

@@ -217,6 +217,7 @@ def create_layout(default_measure_options: list[str]):
         className="app-shell",
         children=[
             dcc.Location(id="url", refresh=False),
+            dcc.Store(id="page-metadata"),
             dcc.Store(id="experiment-result"),
             dcc.Store(id="single-result"),
             dcc.Download(id="csv-download"),

{pymiesimx-0.2.0 → pymiesimx-0.2.2}/PyMieSimX/gui/pages/experiment/page.py

@@ -3,18 +3,25 @@
 
 from dash import dcc, html
 
+from PyMieSimX.gui.sharing import sharing_controls, sharing_feedback
+from PyMieSimX.gui.components.cards import workspace_header
+
 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
 
 
-def build_experiment_page(default_measure_options: list[str], plot_settings: dict | None = None):
+def build_experiment_page(default_measure_options: list[str], plot_settings: dict | None = None, simulation: dict | None = None):
     """Build the isolated Parameter Scan workspace."""
     settings = (plot_settings or {}).get("parameter_sweep", {})
+    projection = (simulation or {}).get("controls", {}).get("plot-experiment-projection", "cartesian")
+    projection_options = [{"label": "Cartesian", "value": "cartesian"}, {"label": "Polar", "value": "polar"}] if projection == "polar" else None
+    initial_plot_options = _plot_options_card("experiment", settings, projection=projection, projection_options=projection_options)
     return html.Div(
         className="tab-content-stack experiment-tab-content",
         children=[
+            workspace_header("Compare scattering across a parameter sweep", "Run a Mie parameter sweep across source, scatterer, and detector settings. Compare scattering measures and export the results as CSV."),
             html.Section(
                 id="configure",
                 className="workspace",
@@ -24,7 +31,6 @@ def build_experiment_page(default_measure_options: list[str], plot_settings: dic
                     html.Section(
                         className="result-column",
                         children=[
-                            _x_axis_card(default_measure_options),
                             html.Div(
                                 className="graph-toolbar",
                                 children=[
@@ -42,6 +48,7 @@ def build_experiment_page(default_measure_options: list[str], plot_settings: dic
                                         disabled=True,
                                         className="toolbar-button toolbar-button-secondary",
                                     ),
+                                    sharing_controls("/experiment"),
                                 ],
                             ),
                             html.Div(
@@ -49,6 +56,8 @@ def build_experiment_page(default_measure_options: list[str], plot_settings: dic
                                 className="experiment-run-feedback",
                                 children=status_banner("idle", "Ready. Click Run to start a sweep."),
                             ),
+                            sharing_feedback(),
+                            _x_axis_card(default_measure_options),
                             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))]),
                         ],
                     ),
@@ -61,7 +70,7 @@ def build_experiment_page(default_measure_options: list[str], plot_settings: dic
                     {"tab_id": "experiment-tab-source", "panel_id": "experiment-panel-source", "label": "Source", "color": "yellow", "content": build_source_section(), "active": False},
                     {"tab_id": "experiment-tab-scatterer", "panel_id": "experiment-panel-scatterer", "label": "Scatterer", "color": "blue", "content": build_scatterer_section(), "active": False},
                     {"tab_id": "experiment-tab-detector", "panel_id": "experiment-panel-detector", "label": "Detector", "color": "cyan", "content": build_detector_section(), "active": False},
-                    {"tab_id": "experiment-tab-plot-options", "panel_id": "experiment-panel-plot-options", "label": "Plot options", "color": "purple", "content": build_plot_options_sidebar("experiment-plot-options-container", _plot_options_card("experiment", settings)), "active": False},
+                    {"tab_id": "experiment-tab-plot-options", "panel_id": "experiment-panel-plot-options", "label": "Plot options", "color": "purple", "content": build_plot_options_sidebar("experiment-plot-options-container", initial_plot_options), "active": False},
                 ],
             ),
         ],