PyMieSimX 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMieSimX
-Version: 0.2.1
+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.1 → pymiesimx-0.2.2}/PyMieSimX/gui/assets/dashboard.css

@@ -4055,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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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},
                 ],
             ),
         ],

{pymiesimx-0.2.1 → pymiesimx-0.2.2}/PyMieSimX/gui/pages/home.py

@@ -29,7 +29,7 @@ def build_home_page(*, home_visits: int | float | None = None):
                         [
                             html.H1("PyMieSim"),
                             html.P(
-                                "An open-source library for fast and flexible far-field Mie scattering simulations.",
+                                "An open-source Mie theory simulator and scattering calculator. Explore individual particles, run parameter sweeps, and export results with PyMieSim.",
                                 className="hero-text",
                             ),
                         ],

{pymiesimx-0.2.1 → pymiesimx-0.2.2}/PyMieSimX/gui/pages/population.py

@@ -4,10 +4,13 @@ import logging
 
 from dash import Input, Output, State, dcc, html, no_update
 from dash.exceptions import PreventUpdate
+
+from PyMieSimX.gui.sharing import sharing_controls, sharing_feedback, shared_setup
 import plotly.graph_objects as go
 import numpy as np
 
 from PyMieSimX.gui.components import Card
+from PyMieSimX.gui.components.cards import workspace_header
 from PyMieSimX.gui.layout import build_tabbed_sidebar, render_field
 from PyMieSimX.gui.material_catalog import material_dropdown_options
 from PyMieSimX.gui.schemas import POPULATION_OPTICAL_FIELDS
@@ -91,19 +94,18 @@ def build_population_page():
     return html.Div(className="page-content-stack population-page", children=[
         dcc.Store(id="population-result"), dcc.Download(id="population-download"),
         dcc.Store(id="population-right-sidebar-active", data=None),
-        html.Section(className="page-hero", children=[
-            html.P("From particles to population properties", className="eyebrow"),
-            html.P("Define particle properties, size distribution, and concentration in the side panels, then compute all optical properties at one wavelength.", className="hero-text"),
-        ]),
+        workspace_header("From particles to population properties", "Define particle properties, size distribution, and concentration in the side panels, then compute all optical properties at one wavelength."),
         html.Section(className="population-workspace", children=[
             html.Div(className="result-column population-output", children=[
                 html.Div(className="graph-toolbar", children=[
-                    html.Button(_compute_label("Compute"), id="population-compute", n_clicks=0,
+                    html.Button(_compute_label("Run"), id="population-compute", n_clicks=0,
                                 className="toolbar-button toolbar-button-primary"),
                     html.Button([html.Span("⤓", className="toolbar-button-icon", **{"aria-hidden": "true"}), "Export CSV"],
                                 id="population-export", disabled=True, className="toolbar-button toolbar-button-secondary"),
+                    sharing_controls("/population"),
                 ]),
-                html.Div(id="population-status", role="status", children="Ready. Click Compute to calculate all properties."),
+                sharing_feedback(),
+                html.Div(id="population-status", role="status", children="Ready. Click Run to calculate all properties."),
                 _panel("Distribution preview", [
                     dcc.Graph(id="population-preview", config={"displaylogo": False}),
                     html.Div(id="population-preview-error", role="status"),
@@ -138,20 +140,28 @@ def register_population_callbacks(app):
         Output("population-minimum-field", "style"), Output("population-maximum-field", "style"),
         Output("population-sampling-field", "style"), Output("population-width", "value"),
         Input("population-distribution", "value"),
+        State("url", "search"),
     )
-    def _population_distribution_controls(distribution):
+    def _population_distribution_controls(distribution, search=""):
+        from dash import ctx
+        setup = shared_setup(search, "/population")
+        width = (setup or {}).get("controls", {}).get("population-width") if setup and not ctx.triggered else None
         hidden = {"display": "none"}
         diameter_label = {"monodisperse": "Diameter [nm]", "gaussian": "Gaussian mean diameter [nm]"}.get(distribution, "Geometric median diameter [nm]")
         return (diameter_label, "Standard deviation [nm]" if distribution == "gaussian" else "Geometric standard deviation",
                 hidden if distribution == "uniform" else {}, {} if distribution in {"gaussian", "lognormal"} else hidden,
                 {} if distribution in {"gaussian", "uniform"} else hidden,
                 {} if distribution in {"gaussian", "uniform"} else hidden,
-                hidden if distribution == "monodisperse" else {}, "50" if distribution == "gaussian" else "1.2")
+                hidden if distribution == "monodisperse" else {}, width if width is not None else "50" if distribution == "gaussian" else "1.2")
 
     @app.callback(Output("population-concentration-label", "children"), Output("population-concentration", "value"),
-                  Input("population-concentration-basis", "value"))
-    def _population_concentration_controls(basis):
-        return ("Particle volume fraction [0–1]", "0.001") if basis == "volume" else ("Number concentration [particles/mL]", "1e9")
+                  Input("population-concentration-basis", "value"), State("url", "search"))
+    def _population_concentration_controls(basis, search=""):
+        from dash import ctx
+        setup = shared_setup(search, "/population")
+        concentration = (setup or {}).get("controls", {}).get("population-concentration") if setup and not ctx.triggered else None
+        label, default = ("Particle volume fraction [0–1]", "0.001") if basis == "volume" else ("Number concentration [particles/mL]", "1e9")
+        return label, concentration if concentration is not None else default
 
     @app.callback(Output("population-preview", "figure"), Output("population-preview-error", "children"),
                   *[Input(f"population-{name}", "value") for name in ("distribution", "diameter", "width", "minimum", "maximum", "sampling")],
@@ -183,7 +193,7 @@ def register_population_callbacks(app):
                   Input("population-compute", "n_clicks"), *[State(_control_id(name), "value") for name in FIELDS],
                   prevent_initial_call=True, running=[
                       (Output("population-compute", "disabled"), True, False),
-                      (Output("population-compute", "children"), _compute_label("Computing…"), _compute_label("Compute")),
+                      (Output("population-compute", "children"), _compute_label("Running…"), _compute_label("Run")),
                       *[(Output(_control_id(name), "disabled"), True, False) for name in FIELDS],
                       *[(Output({"kind": kind, "section": "population", "name": name}, "disabled"),
                          True, not material_dropdown_options(medium=name == "medium"))
@@ -211,7 +221,7 @@ def register_population_callbacks(app):
                   Output("population-export", "disabled", allow_duplicate=True),
                   *[Input(_control_id(name), "value") for name in FIELDS], prevent_initial_call=True)
     def _invalidate_population(*values):
-        return None, [], "Ready. Click Compute to calculate all properties.", True
+        return None, [], "Ready. Click Run to calculate all properties.", True
 
     @app.callback(Output("population-download", "data"), Input("population-export", "n_clicks"),
                   State("population-result", "data"), prevent_initial_call=True)

{pymiesimx-0.2.1 → pymiesimx-0.2.2}/PyMieSimX/gui/pages/single/page.py

@@ -2,24 +2,31 @@
 
 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.defaults import DEFAULT_WORKSPACE_SETTINGS
 from PyMieSimX.gui.layout import PLOT_CONFIG, _plot_options_card, build_plot_options_sidebar, build_tabbed_sidebar
 
 from .sections import build_representation_section, build_scatterer_section, build_source_section
 
 
-def build_single_page(plot_settings: dict | None = None):
+def build_single_page(plot_settings: dict | None = None, simulation: dict | None = None):
     """Build the single page from independent setup and plot sections."""
+    controls = (simulation or {}).get("controls", {})
+    representation = controls.get("single-representation", DEFAULT_WORKSPACE_SETTINGS["particle_explorer"]["representation"])
+    projection = controls.get("single-projection", DEFAULT_WORKSPACE_SETTINGS["particle_explorer"]["projection"])
+    initial_plot_options = _plot_options_card("single", plot_settings or {}, representation=representation, projection=projection)
     return html.Div(
         className="tab-content-stack single-tab-content",
         children=[
+            workspace_header("Explore scattering from a single particle", "Configure the source and scatterer to explore nanoparticle Mie scattering, angular patterns, polarization, and fields."),
             html.Section(
                 className="single-workspace",
                 children=[
                     html.Section(
                         className="result-column",
                         children=[
-                            build_representation_section(),
                             html.Div(
                                 className="graph-toolbar",
                                 children=[
@@ -37,8 +44,11 @@ def build_single_page(plot_settings: dict | None = None):
                                         disabled=True,
                                         className="toolbar-button toolbar-button-secondary",
                                     ),
+                                    sharing_controls("/single"),
                                 ],
                             ),
+                            sharing_feedback(),
+                            build_representation_section(),
                             html.Section(className="panel graph-panel single-graph-panel", children=[dcc.Loading(id="single-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="single-graph", config=PLOT_CONFIG))]),
                         ],
                     ),
@@ -50,7 +60,7 @@ def build_single_page(plot_settings: dict | None = None):
                 [
                     {"tab_id": "single-tab-source", "panel_id": "single-panel-source", "label": "Source", "color": "yellow", "content": build_source_section(), "active": False},
                     {"tab_id": "single-tab-scatterer", "panel_id": "single-panel-scatterer", "label": "Scatterer", "color": "blue", "content": build_scatterer_section(), "active": False},
-                    {"tab_id": "single-tab-plot-options", "panel_id": "single-panel-plot-options", "label": "Plot options", "color": "purple", "content": build_plot_options_sidebar("single-plot-options-container", _plot_options_card("single", plot_settings or {}, representation=DEFAULT_WORKSPACE_SETTINGS["particle_explorer"]["representation"], projection=DEFAULT_WORKSPACE_SETTINGS["particle_explorer"]["projection"])), "active": False},
+                    {"tab_id": "single-tab-plot-options", "panel_id": "single-panel-plot-options", "label": "Plot options", "color": "purple", "content": build_plot_options_sidebar("single-plot-options-container", initial_plot_options), "active": False},
                 ],
             ),
         ],