PyMieSimX 0.1.0__py3-none-any.whl

PyMieSimX/gui/layout.py

@@ -0,0 +1,329 @@
+"""Layout helpers for the experiment dashboard."""
+
+from __future__ import annotations
+
+from dash import dcc, html
+
+from PyMieSimX.gui.defaults import DEFAULT_APPLICATION_SETTINGS, DEFAULT_PLOT_SETTINGS
+from PyMieSimX.gui.schemas import FieldSpec, SECTION_FIELDS, SINGLE_SCATTERER_FIELDS, SINGLE_SOURCE_FIELDS
+
+
+THEME_LIGHT = "https://cdn.jsdelivr.net/npm/bootswatch@5.3.6/dist/flatly/bootstrap.min.css"
+THEME_DARK = "https://cdn.jsdelivr.net/npm/bootswatch@5.3.6/dist/slate/bootstrap.min.css"
+
+PLOT_CONFIG = {
+    "displayModeBar": "always",
+    "displaylogo": False,
+    "scrollZoom": True,
+    "doubleClick": "reset+autosize",
+    "modeBarButtonsToAdd": ["zoomIn2d", "zoomOut2d", "autoScale2d", "resetScale2d"],
+    "toImageButtonOptions": {"format": "png", "filename": "pymiesim_plot", "scale": 2},
+}
+
+
+def _plot_options_card(prefix: str, settings: dict, representation: str | None = None, projection: str | None = None, projection_options: list[dict] | None = None):
+    """Build the neutral, per-plot controls shown beneath each graph."""
+    values = {
+        "x_scale": "linear",
+        "log_y": False,
+        "font_size": 14,
+        "line_width": 2,
+        "show_legend": True,
+        "show_grid": True,
+        "show_title": True,
+        **(settings or {}),
+    }
+
+    def dropdown(name: str, options: list[dict], value):
+        return dcc.Dropdown(
+            id=f"plot-{prefix}-{name}",
+            options=options,
+            value=value,
+            clearable=False,
+            searchable=False,
+            optionHeight=34,
+            maxHeight=170,
+            persistence=True,
+            persistence_type="session",
+            className="dashboard-dropdown plot-option-control",
+        )
+
+    def number(name: str, value, minimum, maximum, step):
+        return dcc.Input(
+            id=f"plot-{prefix}-{name}",
+            type="number",
+            value=value,
+            min=minimum,
+            max=maximum,
+            step=step,
+            placeholder=str(value),
+            persistence=True,
+            persistence_type="session",
+            className="field-input plot-option-control plot-number-control",
+        )
+
+    fields = []
+    is_structured_map = representation in {"stokes", "stokes_q", "stokes_u", "stokes_v", "spf", "farfields"} or str(representation or "").startswith("nearfields")
+    is_polar = prefix == "single" and projection == "polar_1d"
+    is_3d = prefix == "single" and projection in {"3d", "3d_radial"}
+
+    if is_polar:
+        fields.append(("Radial scale", dropdown("y-scale", [{"label": "Linear", "value": False}, {"label": "Logarithmic", "value": True}], bool(values["log_y"]))))
+    elif not is_structured_map and not is_3d:
+        fields.extend([
+            ("X scale", dropdown("x-scale", [{"label": "Linear", "value": "linear"}, {"label": "Logarithmic", "value": "log"}], values["x_scale"])),
+            ("Y scale", dropdown("y-scale", [{"label": "Linear", "value": False}, {"label": "Logarithmic", "value": True}], bool(values["log_y"]))),
+        ])
+    fields.append(("Font size", number("font-size", values["font_size"], 8, 32, 1)))
+    if not is_structured_map and not is_3d:
+        fields.append(("Line width", number("line-width", values["line_width"], 0.5, 8, 0.5)))
+    has_legend = not (prefix == "single" and (is_structured_map or is_3d))
+    if has_legend:
+        fields.append(("Legend", dropdown("legend", [{"label": "Show", "value": True}, {"label": "Hide", "value": False}], bool(values["show_legend"]))))
+    fields.append(("Grid", dropdown("grid", [{"label": "Show", "value": True}, {"label": "Hide", "value": False}], bool(values["show_grid"]))))
+    if prefix == "experiment":
+        fields.insert(2, ("Projection", dropdown("projection", projection_options or [{"label": "Cartesian", "value": "cartesian"}], projection or "cartesian")))
+    return html.Section(
+        className="plot-options-card",
+        children=[
+            html.Div(className="plot-options-title", children="Plot options"),
+            html.Div(className="plot-options-grid", children=[html.Div(className="plot-option-field", children=[html.Label(label), control]) for label, control in fields]),
+        ],
+    )
+
+
+def _x_axis_card(default_measure_options: list[str]):
+    """Build the post-plot X/Y axis selectors, separate from run controls."""
+    return html.Section(
+        className="graph-axis-card",
+        children=[
+            html.Div("Graph axes", className="graph-axis-title"),
+            html.Div(
+                className="graph-axis-fields",
+                children=[
+                    html.Div(
+                        className="graph-axis-field",
+                        children=[
+                            html.Label("X axis", htmlFor="x-axis-select"),
+                            dcc.Dropdown(
+                                id="x-axis-select",
+                                className="dashboard-dropdown graph-axis-control",
+                                options=[],
+                                placeholder="Detected from fields with multiple values",
+                                searchable=False,
+                                optionHeight=38,
+                                maxHeight=200,
+                                persistence=True,
+                                persistence_type="session",
+                            ),
+                        ],
+                    ),
+                    html.Div(
+                        className="graph-axis-field",
+                        children=[
+                            html.Label("Y axis", 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,
+                                searchable=False,
+                                optionHeight=38,
+                                maxHeight=200,
+                                persistence=True,
+                                persistence_type="session",
+                            ),
+                        ],
+                    ),
+                ],
+            ),
+        ],
+    )
+
+
+def create_layout(default_measure_options: list[str]):
+    """Create a route-driven application shell containing only Home initially."""
+    return html.Div(
+        className="app-shell",
+        children=[
+            dcc.Location(id="url", refresh=False),
+            dcc.Store(id="experiment-result"),
+            dcc.Store(id="single-result"),
+            dcc.Download(id="csv-download"),
+            dcc.Download(id="single-csv-download"),
+            dcc.Store(id="home-visit-count", data=0, storage_type="local"),
+            dcc.Store(id="experiment-run-count", data=0, storage_type="local"),
+            dcc.Store(id="single-run-count", data=0, storage_type="local"),
+            dcc.Store(id="theme-store", data={"theme": DEFAULT_APPLICATION_SETTINGS["theme"]}, storage_type="session"),
+            dcc.Store(id="plot-settings-store", data={
+                "particle_explorer": dict(DEFAULT_PLOT_SETTINGS),
+                "parameter_sweep": dict(DEFAULT_PLOT_SETTINGS),
+            }, storage_type="session"),
+            html.Link(id="theme-link", rel="stylesheet", href=THEME_LIGHT),
+            html.Div(
+                className="dashboard-frame",
+                children=[
+                    _build_sidebar(),
+                    html.Main(
+                        id="page-content",
+                        className="dashboard-main",
+                        children=[],
+                    ),
+                ],
+            ),
+        ],
+    )
+
+
+def build_application_footer() -> html.Footer:
+    """Build the global attribution footer shown below every page."""
+    return html.Footer(
+        [
+            "RosettaX is developed and maintained by ",
+            html.A(
+                "Martin Poinsinet de Sivry-Houle",
+                href="mailto:martin.poinsinet.de.sivry@gmail.com",
+                style={
+                    "textDecoration": "none",
+                    "fontWeight": "600",
+                },
+            ),
+            ", at the Amsterdam Vesicle Center.",
+        ],
+        style={
+            "fontSize": "0.88rem",
+            "opacity": 0.72,
+            "textAlign": "center",
+            "paddingTop": "12px",
+            "paddingBottom": "8px",
+        },
+    )
+
+
+def build_page_with_footer(page):
+    """Wrap a routed page with the shared RosettaX-style footer."""
+    return html.Div(
+        children=[page, build_application_footer()],
+        style={
+            "flex": "1 0 auto",
+            "display": "flex",
+            "flexDirection": "column",
+            "gap": "24px",
+        },
+    )
+
+
+def _build_sidebar():
+    """Create the dashboard sidebar."""
+    return html.Aside(
+        className="dashboard-sidebar",
+        children=[
+            html.Div(
+                className="sidebar-brand",
+                children=[
+                    dcc.Link(
+                        html.Img(id="sidebar-logo", src="/assets/pymiesim-logo.svg", alt="PyMieSim home", className="sidebar-logo"),
+                        href="/",
+                        refresh=False,
+                        className="sidebar-logo-link",
+                    ),
+                ],
+            ),
+            html.Nav(
+                className="sidebar-nav",
+                children=[
+                    _sidebar_link("Home", "/"),
+                    _sidebar_link("Particle Explorer", "/single"),
+                    _sidebar_link("Parameter Sweep", "/experiment"),
+                    _sidebar_link("Documentation", "/documentation"),
+                    _sidebar_link("Settings", "/settings"),
+                ],
+            ),
+        ],
+    )
+
+
+def build_theme_selector():
+    """Build the persisted Light/Dark selector used by the application shell."""
+    return dcc.Dropdown(
+        id="theme-mode",
+        options=[
+            {"label": "Dark", "value": "dark"},
+            {"label": "Light", "value": "light"},
+        ],
+        value=DEFAULT_APPLICATION_SETTINGS["theme"],
+        clearable=False,
+        searchable=False,
+        optionHeight=38,
+        maxHeight=200,
+        persistence=True,
+        persistence_type="session",
+        className="theme-mode-select",
+    )
+
+
+def _sidebar_link(label: str, href: str):
+    """Build a single sidebar anchor."""
+    # Keep route-based IDs stable while allowing user-facing labels to evolve.
+    link_id = f"sidebar-link-{href.strip('/') or 'home'}"
+    return dcc.Link(label, id=link_id, href=href, refresh=False, className="sidebar-link active" if label == "Home" else "sidebar-link")
+
+
+def render_fields(section: str, section_type: str):
+    """Render all fields for one selected section type."""
+    schemas = {"single-source": SINGLE_SOURCE_FIELDS, "single-scatterer": SINGLE_SCATTERER_FIELDS}
+    field_specs = schemas[section][section_type] if section in schemas else SECTION_FIELDS[section][section_type]
+
+    if not field_specs:
+        return html.Div("This parameter sweep runs without a detector set.", className="empty-section")
+
+    return html.Div(className="field-grid", children=[render_field(section, field_spec) for field_spec in field_specs])
+
+
+def render_field(section: str, field_spec: FieldSpec):
+    """Render one schema field as a labeled text input."""
+    persistence = "parameter-sweep-defaults-v2" if section in {"source", "scatterer", "detector"} else True
+    default_class = " field-input-default" if section == "detector" and field_spec.name in {"polarization_filter", "medium"} else ""
+    return html.Div(
+        className="field-block",
+        children=[
+            html.Label(_format_field_label(field_spec)),
+            dcc.Input(
+                id={"kind": "field", "section": section, "name": field_spec.name},
+                type="text",
+                value=field_spec.default,
+                debounce=False,
+                placeholder=field_spec.placeholder or field_spec.default,
+                className=f"field-input{default_class}",
+                persistence=persistence,
+                persistence_type="session",
+            ),
+        ],
+    )
+
+
+def render_summary_cards(summary: list[dict[str, str]]):
+    """Render compact summary cards for one experiment run."""
+    if not summary:
+        return [html.Div(className="summary-card", children=[html.Span("No result yet"), html.Strong("Run a parameter sweep")])]
+
+    return [
+        html.Div(className="summary-card", children=[html.Span(item["label"]), html.Strong(item["value"])])
+        for item in summary
+    ]
+
+
+def _build_default_help_text(field_spec: FieldSpec) -> str:
+    """Return a fallback field description."""
+    if field_spec.unit is None:
+        return "Scalar values, comma-separated values, or start:end:count are supported when meaningful."
+
+    return f"Values are interpreted in {field_spec.unit}."
+
+
+def _format_field_label(field_spec: FieldSpec) -> str:
+    """Put the unit beside the label so cards stay compact."""
+    if field_spec.unit is None:
+        return field_spec.label
+    return f"{field_spec.label} [{field_spec.unit}]"

PyMieSimX/gui/pages/__init__.py

@@ -0,0 +1,9 @@
+"""Page modules for the PyMieSim Dash application."""
+
+from .documentation import build_documentation_page
+from .citation import build_citation_page
+from .home import build_home_page
+from .install_local import build_install_local_page
+from .settings import build_settings_page
+
+__all__ = ["build_citation_page", "build_documentation_page", "build_home_page", "build_install_local_page", "build_settings_page"]

PyMieSimX/gui/pages/citation.py

@@ -0,0 +1,66 @@
+"""Citation page composition."""
+
+from dash import html
+
+from PyMieSimX.gui.components import Card
+
+
+PYMIESIM_DOI = "10.1364/OPTCON.473102"
+PYMIESIM_ARTICLE_URL = "https://opg.optica.org/optcon/fulltext.cfm?uri=optcon-2-3-520"
+PYMIESIM_BIBTEX = """@article{PoinsinetdeSivry-Houle:23,
+  author = {Martin Poinsinet de Sivry-Houle and Nicolas Godbout and Caroline Boudoux},
+  journal = {Opt. Continuum},
+  title = {PyMieSim: an open-source library for fast and flexible far-field Mie scattering simulations},
+  volume = {2},
+  number = {3},
+  pages = {520--534},
+  year = {2023},
+  doi = {10.1364/OPTCON.473102},
+}"""
+
+
+def build_citation_page():
+    """Build the citation page shown by the home-page citation button."""
+    return html.Div(
+        className="page-content-stack",
+        children=[
+            html.Section(
+                className="page-hero documentation-page-hero",
+                children=[
+                    html.P("PyMieSim reference", className="eyebrow"),
+                    html.H1("Cite PyMieSim"),
+                    html.P(
+                        "Use this reference when PyMieSim contributes to a scientific workflow, analysis, or publication.",
+                        className="hero-text",
+                    ),
+                ],
+            ),
+            html.Section(
+                className=Card.classes(color="blue", extra="panel documentation-card"),
+                children=[
+                    html.Div(className="card-header panel-header", children=[html.H2("BibTeX")]),
+                    html.Div(className="card-body", children=[
+                        html.Div("Copy this reference into your bibliography file.", className="home-info-copy"),
+                        html.Pre(PYMIESIM_BIBTEX, className="citation-bibtex"),
+                    ]),
+                ],
+            ),
+            html.Section(
+                className=Card.classes(color="blue", extra="panel documentation-card"),
+                children=[
+                    html.Div(className="card-header panel-header", children=[html.H2("Publication")]),
+                    html.Div(className="card-body", children=[
+                        html.Div(f"DOI: {PYMIESIM_DOI}", className="home-info-copy"),
+                        html.A("View publication", href=PYMIESIM_ARTICLE_URL, target="_blank", rel="noopener noreferrer", className="inline-action"),
+                    ]),
+                ],
+            ),
+            html.Section(
+                className=Card.classes(color="blue", extra="panel documentation-card"),
+                children=[
+                    html.Div(className="card-header panel-header", children=[html.H2("Citation guidance")]),
+                    html.Div(className="card-body", children=[html.P("Please cite the publication above when using PyMieSim in academic work.")]),
+                ],
+            ),
+        ],
+    )

PyMieSimX/gui/pages/documentation.py

@@ -0,0 +1,132 @@
+"""Documentation hub page composition."""
+
+from dash import html
+
+from PyMieSimX.gui.components import Card
+
+
+def build_documentation_page():
+    """Build the in-app guide to PyMieSim workflows and vocabulary."""
+    return html.Div(
+        className="page-content-stack documentation-page",
+        children=[
+            html.Section(
+                className="page-hero documentation-page-hero",
+                children=[
+                    html.P("PyMieSim reference", className="eyebrow"),
+                    html.H1("Documentation"),
+                    html.P("A practical guide to building optical setups, running sweeps, reading representations, and entering values efficiently.", className="hero-text"),
+                    html.Div(
+                        className="documentation-hero-actions",
+                        children=[
+                            html.A("Start a parameter sweep →", href="/experiment", className="home-button home-button-primary"),
+                            html.A("Open Particle Explorer →", href="/single", className="home-button home-button-outline"),
+                        ],
+                    ),
+                ],
+            ),
+            html.Section(
+                className=Card.classes(color="blue", extra="panel documentation-quickstart"),
+                children=[
+                    html.Div(className="card-header panel-header", children=[html.H2("Quick start")]),
+                    html.Div(
+                        className="card-body documentation-quickstart-body",
+                        children=[
+                            _step("01", "Choose a workspace", "Use Parameter Sweep for parameter sweeps and detector coupling. Use Particle Explorer to inspect one optical setup."),
+                            _step("02", "Configure the objects", "Pick a source, scatterer, and—when needed—a detector. Each card exposes the fields supported by that model."),
+                            _step("03", "Enter values or sweeps", "Use one value for a focused run, a comma-separated list for selected values, or start:end:count for an evenly spaced sweep."),
+                            _step("04", "Render and inspect", "Run the calculation, select the X axis when several fields vary, and use Settings to tune the resulting plots."),
+                        ],
+                    ),
+                ],
+            ),
+            html.Div(
+                className="documentation-grid documentation-topic-grid",
+                children=[
+                    _guide_card("yellow", "Parameter Sweep", "Sweep a parameter space", "Build source, scatterer, and detector sets, then evaluate a measure over every combination.", ["X-axis is inferred from fields with multiple values.", "Detector-free runs are supported.", "Results can be exported as CSV."], "/experiment", "Open Parameter Sweep"),
+                    _guide_card("blue", "Particle Explorer", "Understand one setup", "Inspect angular amplitudes, polarization, phase functions, or far-field intensity for one source and scatterer.", ["Choose a representation.", "Control angular sampling.", "Render the figure on demand."], "/single", "Open Particle Explorer"),
+                    _guide_card("cyan", "Plot settings", "Make figures your own", "Set typography, line and marker sizes, grid visibility, legend visibility, and light or dark plot styling.", ["Preferences are saved in this browser.", "Settings apply to both workspaces.", "The application theme is controlled here."], "/settings", "Open Settings"),
+                    _guide_card("purple", "Citation", "Reference the project", "Find the publication details and ready-to-copy BibTeX entry for work that uses PyMieSim.", ["Publication DOI is included.", "BibTeX is formatted for direct copying.", "Citation guidance is kept with the reference."], "/citation", "View Citation"),
+                ],
+            ),
+            html.Div(
+                className="documentation-columns",
+                children=[
+                    _syntax_card(),
+                    _vocabulary_card(),
+                ],
+            ),
+            html.Section(
+                className=Card.classes(color="green", extra="panel documentation-models"),
+                children=[
+                    html.Div(className="card-header panel-header", children=[html.H2("Supported model families")]),
+                    html.Div(
+                        className="card-body documentation-model-grid",
+                        children=[
+                            _model_group("Sources", "Gaussian", "Plane wave"),
+                            _model_group("Scatterers", "Sphere", "Infinite cylinder", "Core-shell"),
+                            _model_group("Detectors", "Photodiode", "Coherent mode", "No detector"),
+                            _model_group("Representations", "S1 / S2", "Stokes", "SPF", "Far-field"),
+                        ],
+                    ),
+                ],
+            ),
+            html.Section(
+                className=Card.classes(color="blue", extra="panel documentation-note"),
+                children=[
+                    html.Div(className="card-header panel-header", children=[html.H2("Need more detail?")]),
+                    html.Div(className="card-body documentation-note-body", children=[html.P("The dashboard is designed to keep the common path visible: configure an object, run a calculation, then refine the plot. For local installation instructions and release links, open the installation guide."), html.A("Open installation guide →", href="/documentation/install-local", className="inline-action")]),
+                ],
+            ),
+        ],
+    )
+
+
+def _step(number: str, title: str, description: str):
+    return html.Div(className="documentation-step", children=[html.Span(number, className="documentation-step-number"), html.Div([html.H3(title), html.P(description)])])
+
+
+def _guide_card(color: str, eyebrow: str, title: str, description: str, bullets: list[str], href: str, action: str):
+    return html.Section(
+        className=Card.classes(color=color, extra="panel documentation-guide-card"),
+        children=[
+            html.Div(className="card-header panel-header", children=[html.Span(eyebrow, className="documentation-card-kicker"), html.H2(title)]),
+            html.Div(className="card-body", children=[html.P(description), html.Ul([html.Li(item) for item in bullets], className="documentation-bullet-list"), html.A(f"{action} →", href=href, className="inline-action")]),
+        ],
+    )
+
+
+def _syntax_card():
+    examples = (
+        ("600", "One scalar value"),
+        ("600,800,1000", "An explicit list"),
+        ("400:1400:8", "Eight evenly spaced values"),
+        ("LP01,HG11", "A list of names or modes"),
+    )
+    return html.Section(
+        className=Card.classes(color="orange", extra="panel documentation-detail-card"),
+        children=[
+            html.Div(className="card-header panel-header", children=[html.H2("Field syntax")]),
+            html.Div(className="card-body", children=[html.P("Most text fields accept compact batch input. The same notation works for optical quantities, material values, angles, and named modes."), html.Div([html.Div(className="documentation-syntax-row", children=[html.Code(value), html.Span(description)]) for value, description in examples], className="documentation-syntax-list"), html.P("Keep the X axis on a field that actually varies if you want a clean one-dimensional plot.", className="documentation-callout")]),
+        ],
+    )
+
+
+def _vocabulary_card():
+    rows = (
+        ("Source", "The incident illumination, such as Gaussian or plane wave."),
+        ("Scatterer", "The object being simulated, such as a sphere or core-shell particle."),
+        ("Detector", "The collection model used for detector-specific measures and coupling."),
+        ("Measure", "The quantity computed from the selected source, scatterer, and detector."),
+    )
+    return html.Section(
+        className=Card.classes(color="purple", extra="panel documentation-detail-card"),
+        children=[
+            html.Div(className="card-header panel-header", children=[html.H2("Core vocabulary")]),
+            html.Div(className="card-body documentation-definition-list", children=[html.Div([html.Strong(term), html.Span(description)]) for term, description in rows]),
+        ],
+    )
+
+
+def _model_group(title: str, *models: str):
+    return html.Div(className="documentation-model-group", children=[html.H3(title), html.Div([html.Span(model, className="documentation-model-pill") for model in models], className="documentation-model-pills")])

PyMieSimX/gui/pages/experiment/__init__.py

@@ -0,0 +1,5 @@
+"""Parameter Sweep page and sections."""
+
+from .page import build_experiment_page
+
+__all__ = ["build_experiment_page"]

PyMieSimX/gui/pages/experiment/page.py

@@ -0,0 +1,49 @@
+"""Parameter Sweep page composition."""
+
+from __future__ import annotations
+
+from dash import dcc, html
+
+from PyMieSimX.gui.components import HeaderCard
+from PyMieSimX.gui.layout import PLOT_CONFIG, _plot_options_card, _x_axis_card
+
+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):
+    """Build the isolated Parameter Sweep workspace."""
+    settings = (plot_settings or {}).get("parameter_sweep", {})
+    return html.Div(
+        className="tab-content-stack experiment-tab-content",
+        children=[
+            HeaderCard(
+                "Parameter Sweep Lab",
+                "Configure source, scatterer, and detector sets, then run parameter sweeps through the compiled engine directly from Dash.",
+                [
+                    ("01", "Configure source", "Choose the source family and sweep its optical parameters.", "yellow"),
+                    ("02", "Configure scatterer", "Set particle geometry, material, and medium values.", "blue"),
+                    ("03", "Configure detector", "Select collection geometry and compute the sweep response.", "orange"),
+                ],
+                color="green",
+            ).render(),
+            html.Section(
+                id="configure",
+                className="workspace",
+                children=[
+                    html.Section(
+                        className="control-column",
+                        children=[html.Div(className="set-panel-grid", children=[build_source_section(), build_scatterer_section(), build_detector_section()])],
+                    ),
+                    html.Section(
+                        className="result-column",
+                        children=[
+                            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=html.Div(className="plot-loading-target", children=[dcc.Graph(id="result-graph", config=PLOT_CONFIG), html.Div(id="experiment-computation-status", style={"display": "none"})]))]),
+                            _x_axis_card(default_measure_options),
+                            html.Div(id="experiment-plot-options-container", children=[_plot_options_card("experiment", settings)]),
+                            html.Div(className="export-actions", children=[html.Button("Export CSV", id="export-csv", n_clicks=0, className="run-button export-button")]),
+                        ],
+                    ),
+                ],
+            ),
+        ],
+    )

PyMieSimX/gui/pages/experiment/sections/__init__.py

@@ -0,0 +1,5 @@
+"""Experiment workflow sections."""
+
+from .configuration import build_detector_section, build_scatterer_section, build_source_section
+
+__all__ = ["build_detector_section", "build_scatterer_section", "build_source_section"]

PyMieSimX/gui/pages/experiment/sections/configuration.py

@@ -0,0 +1,42 @@
+"""Source, scatterer, and detector configuration cards."""
+
+from dash import dcc, html
+
+from PyMieSimX.gui.components import Card
+from PyMieSimX.gui.defaults import DEFAULT_WORKSPACE_SETTINGS
+from PyMieSimX.gui.schemas import SECTION_FIELDS
+
+
+def build_source_section():
+    return _build_section("Source Set", "source-type", "source-fields", SECTION_FIELDS["source"], DEFAULT_WORKSPACE_SETTINGS["parameter_sweep"]["source_type"], color="yellow", info="Configure the optical source and its wavelength, polarization, and amplitude values.")
+
+
+def build_scatterer_section():
+    return _build_section("Scatterer Set", "scatterer-type", "scatterer-fields", SECTION_FIELDS["scatterer"], DEFAULT_WORKSPACE_SETTINGS["parameter_sweep"]["scatterer_type"], color="blue", info="Configure particle geometry, material, and surrounding medium values.")
+
+
+def build_detector_section():
+    return _build_section("Detector Set", "detector-type", "detector-fields", SECTION_FIELDS["detector"], DEFAULT_WORKSPACE_SETTINGS["parameter_sweep"]["detector_type"], detector=True, color="cyan", info="Configure detector collection geometry, sampling, offsets, and mode settings.")
+
+
+def _build_section(title, selector_id, fields_id, choices, default, detector=False, color="blue", info=""):
+    options = [{"label": "No detector" if detector and key == "None" else key.replace("Set", ""), "value": key} for key in choices]
+    persistence_key = "parameter-sweep-detector-default-v3" if detector else "parameter-sweep-defaults-v2"
+    detector_alert = (
+        html.Div(
+            "A detector is required to compute coupling. Select a detector to enable it.",
+            id="detector-coupling-alert",
+            className="detector-coupling-alert",
+        )
+        if detector
+        else None
+    )
+    return html.Details(
+        id=f"{selector_id}-card",
+        className=Card.classes(color=color, extra="workflow-card"),
+        open=True,
+        children=[
+            html.Summary(children=[html.Span(title), html.Span("i", className="workflow-info-button", title=info, **{"aria-label": info})]),
+            html.Div(className="workflow-card-body", children=[dcc.Dropdown(id=selector_id, className="dashboard-dropdown", options=options, value=default, clearable=False, searchable=False, optionHeight=38, maxHeight=200, persistence=persistence_key, persistence_type="session"), detector_alert, html.Div(id=fields_id, className="panel-body")]),
+        ],
+    )