Redesign UI: cleaner layout, better plots, custom CSS

- Centered header with description instead of raw markdown
- Summary card with styled parameter table
- KDE posterior plots with rug marks replacing violin plots
- Higher DPI (140), tighter figure sizing
- Custom CSS for spacing, card styling, section headings
- Cleaner About tab with comparison table

Made-with: Cursor

app.py

@@ -502,38 +502,25 @@ def _build_summary_text(result, recon=None, domain="ec"):
     prob = result["mechanism_probs"][mech]
 
     lines = [
-        f"## Predicted Mechanism: **{mech}** ({prob:.1%} confidence)\n",
+        f"<div style='text-align:center; padding: 12px 0 4px 0;'>",
+        f"<span style='font-size:1.5em; font-weight:700;'>{mech}</span>",
+        f"<br><span style='font-size:1.1em; color:#6B7280;'>{prob:.1%} confidence</span>",
+        f"</div>\n",
     ]
 
     stats = result["parameter_stats"].get(mech)
     if stats:
-        lines.append("### Parameter Estimates (90% Credible Interval)\n")
-        lines.append("| Parameter | Mean | 90% CI |")
-        lines.append("|-----------|------|--------|")
+        lines.append("#### Parameter Estimates\n")
+        lines.append("| Parameter | Mean | 90 % CI |")
+        lines.append("|:----------|-----:|:--------|")
         for i, name in enumerate(stats["names"]):
             mean = stats["mean"][i]
             q05 = stats["q05"][i]
             q95 = stats["q95"][i]
-            lines.append(f"| {name} | {mean:.4f} | [{q05:.4f}, {q95:.4f}] |")
+            lines.append(f"| **{name}** | {mean:.4f} | [{q05:.4f}, {q95:.4f}] |")
 
-    if recon is not None:
-        lines.append("\n### Signal Reconstruction Quality\n")
-        lines.append(f"- **Average NRMSE**: {recon['mean_nrmse']:.4f}")
-        lines.append(f"- **Average R\u00b2**: {recon['mean_r2']:.4f}")
-        if len(recon["nrmse"]) > 1:
-            lines.append("\n| Curve | NRMSE | R\u00b2 |")
-            lines.append("|-------|-------|-----|")
-            for i, (n, r) in enumerate(zip(recon["nrmse"], recon["r2"])):
-                lines.append(f"| {i + 1} | {n:.4f} | {r:.4f} |")
-
-    lines.append("\n### All Mechanism Probabilities\n")
-    lines.append("| Mechanism | Probability |")
-    lines.append("|-----------|-------------|")
-    sorted_mechs = sorted(result["mechanism_probs"].items(), key=lambda x: -x[1])
-    for m, p in sorted_mechs:
-        marker = " \u2190 predicted" if m == mech else ""
-        lines.append(f"| {m} | {p:.4f} |{marker}")
-    lines.append("\n*Use the dropdown below to view posteriors and reconstruction for any mechanism.*")
+    if recon is not None and np.isfinite(recon["mean_nrmse"]):
+        lines.append(f"\n#### Reconstruction &nbsp; NRMSE {recon['mean_nrmse']:.4f} &nbsp;|&nbsp; R\u00b2 {recon['mean_r2']:.4f}\n")
 
     result_json = {
         "predicted_mechanism": mech,
@@ -568,73 +555,74 @@ def download_results(result_text):
 # =========================================================================
 
 def _build_ec_output_section(prefix):
-    """Build shared output components for one EC input tab.
-
-    Returns (probs_plot, summary_md, state, mech_dropdown,
-             posteriors_plot, recon_plot, conc_plot).
-    """
-    with gr.Row():
-        probs = gr.Plot(label="Mechanism Classification")
-        summary = gr.Markdown(label="Summary")
+    """Build shared output components for one EC input tab."""
+    gr.Markdown("### Results", elem_classes=["section-heading"])
+    with gr.Row(equal_height=False):
+        with gr.Column(scale=2, min_width=320):
+            probs = gr.Plot(label="Mechanism Probabilities", show_label=False)
+        with gr.Column(scale=1, min_width=260):
+            summary = gr.Markdown(label="Summary", elem_classes=["summary-card"])
     state = gr.State(value=None)
-    gr.Markdown("---")
-    gr.Markdown(
-        "### Mechanism Details\n"
-        "Select a mechanism below to view its parameter posteriors, "
-        "signal reconstruction, and surface concentration profiles."
-    )
+    gr.Markdown("### Explore Mechanisms", elem_classes=["section-heading"])
     mech_dd = gr.Dropdown(
-        label="View mechanism (select to explore alternatives)",
+        label="Select mechanism",
         choices=[],
         interactive=True,
     )
-    posteriors = gr.Plot(label="Parameter Posteriors")
-    with gr.Row():
-        recon = gr.Plot(label="Signal Reconstruction")
-        conc = gr.Plot(label="Surface Concentration Profiles")
+    posteriors = gr.Plot(label="Parameter Posteriors", show_label=False)
+    recon = gr.Plot(label="Signal Reconstruction", show_label=False)
+    conc = gr.Plot(label="Surface Concentrations", show_label=False)
     return probs, summary, state, mech_dd, posteriors, recon, conc
 
 
 def _build_tpd_output_section(prefix):
-    """Build shared output components for one TPD input tab.
-
-    Returns (probs_plot, summary_md, state, mech_dropdown,
-             posteriors_plot, recon_plot).
-    """
-    with gr.Row():
-        probs = gr.Plot(label="Mechanism Classification")
-        summary = gr.Markdown(label="Summary")
+    """Build shared output components for one TPD input tab."""
+    gr.Markdown("### Results", elem_classes=["section-heading"])
+    with gr.Row(equal_height=False):
+        with gr.Column(scale=2, min_width=320):
+            probs = gr.Plot(label="Mechanism Probabilities", show_label=False)
+        with gr.Column(scale=1, min_width=260):
+            summary = gr.Markdown(label="Summary", elem_classes=["summary-card"])
     state = gr.State(value=None)
-    gr.Markdown("---")
-    gr.Markdown(
-        "### Mechanism Details\n"
-        "Select a mechanism below to view its parameter posteriors "
-        "and signal reconstruction."
-    )
+    gr.Markdown("### Explore Mechanisms", elem_classes=["section-heading"])
     mech_dd = gr.Dropdown(
-        label="View mechanism (select to explore alternatives)",
+        label="Select mechanism",
         choices=[],
         interactive=True,
     )
-    posteriors = gr.Plot(label="Parameter Posteriors")
-    recon = gr.Plot(label="Signal Reconstruction")
+    posteriors = gr.Plot(label="Parameter Posteriors", show_label=False)
+    recon = gr.Plot(label="Signal Reconstruction", show_label=False)
     return probs, summary, state, mech_dd, posteriors, recon
 
 
+CUSTOM_CSS = """
+.main-header { text-align: center; padding: 24px 16px 8px 16px; }
+.main-header h1 { font-size: 2.2em; margin-bottom: 2px; letter-spacing: -0.5px; }
+.main-header p  { color: #6B7280; font-size: 1.05em; max-width: 720px; margin: 0 auto; line-height: 1.5; }
+.section-heading { margin-top: 20px !important; margin-bottom: 4px !important; }
+.summary-card { border: 1px solid #E5E7EB; border-radius: 10px; padding: 16px 20px; background: #FAFBFC; }
+.summary-card table { width: 100%; font-size: 0.92em; }
+.summary-card td, .summary-card th { padding: 4px 8px; }
+footer { display: none !important; }
+"""
+
+
 def build_app():
     with gr.Blocks(
         title="ECFlow — Bayesian Inference for Electrochemistry & Catalysis",
         theme=gr.themes.Soft(
             primary_hue="blue",
-            secondary_hue="purple",
+            secondary_hue="slate",
+            font=gr.themes.GoogleFont("Inter"),
         ),
+        css=CUSTOM_CSS,
     ) as app:
-        gr.Markdown(
-            "# ECFlow\n"
-            "### Amortized Bayesian Inference for Electrochemistry & Catalysis\n"
-            "Upload cyclic voltammetry (CV) or temperature-programmed desorption (TPD) data "
-            "to identify the reaction mechanism and infer kinetic parameters with full uncertainty quantification.",
-            elem_classes=["main-title"],
+        gr.HTML(
+            "<div class='main-header'>"
+            "<h1>⚡ ECFlow</h1>"
+            "<p>Upload cyclic voltammetry or TPD data to <strong>identify the reaction mechanism</strong> "
+            "and <strong>infer kinetic parameters</strong> with full Bayesian uncertainty — in milliseconds.</p>"
+            "</div>"
         )
 
         with gr.Tabs():
@@ -895,50 +883,30 @@ def build_app():
             # =================================================================
             with gr.Tab("About"):
                 gr.Markdown("""
-## About ECFlow
-
-ECFlow performs **amortized Bayesian inference** for electrochemical and catalytic systems.
-Given experimental data, it simultaneously:
-
-1. **Classifies the reaction mechanism** from a library of 6 mechanisms per domain
-2. **Infers kinetic parameters** with full posterior uncertainty quantification
-
-### Electrochemistry (CV) Mechanisms
+## How It Works
 
-| Mechanism | Parameters | Description |
-|-----------|-----------|-------------|
-| Nernst | E₀, d_A, d_B | Reversible (Nernstian) electron transfer |
-| BV | K₀, α, d_B | Butler-Volmer kinetics |
-| MHC | K₀, λ, d_B | Marcus-Hush-Chidsey kinetics |
-| Ads | K₀, α, Γ_sat | Surface-confined (Laviron) kinetics |
-| EC | K₀, α, k_c, d_B | Electron transfer + chemical follow-up |
-| LH | K₀, α, K_A, K_B, d_B | Langmuir-Hinshelwood surface reaction |
+ECFlow uses **conditional normalizing flows** with a **Set Transformer** encoder to perform amortized Bayesian inference.
+Given one or more experimental curves, it simultaneously classifies the reaction mechanism and produces
+full posterior distributions over kinetic parameters — in a single forward pass.
 
-### Catalysis (TPD) Mechanisms
+| | Electrochemistry (CV) | Catalysis (TPD) |
+|---|---|---|
+| **Mechanisms** | Nernst, Butler–Volmer, Marcus–Hush–Chidsey, Adsorption, EC, Langmuir–Hinshelwood | First-order, Second-order, LH Surface, Mars–van Krevelen, Coverage-dependent, Diffusion-limited |
+| **Inference** | ~50 ms on CPU | ~50 ms on CPU |
+| **Calibration** | 89–94 % coverage at 90 % nominal | Conformal coverage verified |
 
-| Mechanism | Parameters | Description |
-|-----------|-----------|-------------|
-| FirstOrder | E_d, ν, θ₀ | First-order desorption |
-| SecondOrder | E_d, ν, θ₀ | Second-order (recombinative) desorption |
-| LH_Surface | E_a, ν, θ_A0, θ_B0 | Langmuir-Hinshelwood surface reaction |
-| MvK | E_a,red, E_a,reox, ν_red, θ_O0 | Mars-van Krevelen mechanism |
-| FirstOrderCovDep | E_d0, α_cov, ν, θ₀ | Coverage-dependent activation energy |
-| DiffLimited | E_d, ν, D₀, E_diff, θ₀ | Diffusion-limited desorption |
-
-### How It Works
-
-The model uses **conditional normalizing flows** with a Set Transformer encoder
-to process multi-scan-rate/multi-heating-rate data. Training uses simulated data
-with coverage-aware calibration loss for well-calibrated uncertainty estimates.
-
-Inference takes **~5 ms per sample** on CPU, making it suitable for real-time analysis.
+Training data is generated from physics-based simulators (Crank–Nicolson for CV, ODE integrators for TPD).
+Posteriors are calibrated via a coverage-aware loss with per-parameter inverse-spread weighting.
 
 ### Citation
 
-If you use ECFlow in your research, please cite:
 ```
-[Citation to be added upon publication]
+Yan, B. (2026). ECFlow: Amortized Bayesian Inference for Mechanism Identification
+and Parameter Estimation in Electrochemistry and Catalysis via Conditional
+Normalizing Flows. [Preprint]
 ```
+
+Built at MIT. Code and paper at [github.com/bingyan/ECFlow](https://github.com/bingyan/ECFlow).
 """)
 
     return app

plotting.py

@@ -11,148 +11,146 @@ matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 from matplotlib.gridspec import GridSpec
 
-
-COLORS = {
-    "primary": "#2563EB",
-    "secondary": "#7C3AED",
-    "accent": "#059669",
-    "warm": "#DC2626",
-    "neutral": "#6B7280",
-    "bg": "#F9FAFB",
+plt.rcParams.update({
+    "figure.dpi": 140,
+    "font.family": "sans-serif",
+    "font.size": 10,
+    "axes.titlesize": 12,
+    "axes.labelsize": 10,
+    "xtick.labelsize": 9,
+    "ytick.labelsize": 9,
+    "legend.fontsize": 9,
+    "figure.facecolor": "white",
+    "axes.facecolor": "white",
+    "savefig.facecolor": "white",
+    "axes.spines.top": False,
+    "axes.spines.right": False,
+})
+
+PAL = {
+    "blue":   "#2563EB",
+    "purple": "#7C3AED",
+    "pink":   "#EC4899",
+    "amber":  "#F59E0B",
+    "green":  "#10B981",
+    "red":    "#EF4444",
+    "gray":   "#9CA3AF",
+    "dark":   "#1F2937",
+    "light":  "#F3F4F6",
 }
 
 MECH_COLORS_EC = {
-    "Nernst": "#3B82F6",
-    "BV": "#8B5CF6",
-    "MHC": "#EC4899",
-    "Ads": "#F59E0B",
-    "EC": "#10B981",
-    "LH": "#EF4444",
+    "Nernst": PAL["blue"],
+    "BV":     PAL["purple"],
+    "MHC":    PAL["pink"],
+    "Ads":    PAL["amber"],
+    "EC":     PAL["green"],
+    "LH":     PAL["red"],
 }
 
 MECH_COLORS_TPD = {
-    "FirstOrder": "#3B82F6",
-    "SecondOrder": "#8B5CF6",
-    "LH_Surface": "#EC4899",
-    "MvK": "#F59E0B",
-    "FirstOrderCovDep": "#10B981",
-    "DiffLimited": "#EF4444",
+    "FirstOrder":       PAL["blue"],
+    "SecondOrder":      PAL["purple"],
+    "LH_Surface":       PAL["pink"],
+    "MvK":              PAL["amber"],
+    "FirstOrderCovDep": PAL["green"],
+    "DiffLimited":      PAL["red"],
 }
 
 
 def plot_mechanism_probs(probs_dict, domain="ec"):
-    """
-    Horizontal bar chart of mechanism classification probabilities.
-
-    Args:
-        probs_dict: {mechanism_name: probability}
-        domain: 'ec' or 'tpd'
-
-    Returns:
-        matplotlib Figure
-    """
+    """Horizontal bar chart of mechanism classification probabilities."""
     colors = MECH_COLORS_EC if domain == "ec" else MECH_COLORS_TPD
     names = list(probs_dict.keys())
     probs = [probs_dict[n] for n in names]
 
-    sorted_idx = np.argsort(probs)
-    names = [names[i] for i in sorted_idx]
-    probs = [probs[i] for i in sorted_idx]
-    bar_colors = [colors.get(n, COLORS["neutral"]) for n in names]
+    idx = np.argsort(probs)
+    names  = [names[i] for i in idx]
+    probs  = [probs[i] for i in idx]
+    bar_c  = [colors.get(n, PAL["gray"]) for n in names]
 
-    fig, ax = plt.subplots(figsize=(8, max(3, len(names) * 0.6)))
-    bars = ax.barh(range(len(names)), probs, color=bar_colors, edgecolor="white",
-                   linewidth=0.5, height=0.7)
+    fig, ax = plt.subplots(figsize=(6, max(2.4, len(names) * 0.52)))
+    bars = ax.barh(range(len(names)), probs, color=bar_c,
+                   edgecolor="white", linewidth=0.6, height=0.65,
+                   zorder=3)
 
     ax.set_yticks(range(len(names)))
-    ax.set_yticklabels(names, fontsize=12, fontweight="medium")
-    ax.set_xlim(0, 1.05)
-    ax.set_xlabel("Probability", fontsize=12)
-    ax.set_title("Mechanism Classification", fontsize=14, fontweight="bold", pad=15)
-
-    for i, (bar, prob) in enumerate(zip(bars, probs)):
-        if prob > 0.05:
-            ax.text(bar.get_width() + 0.02, bar.get_y() + bar.get_height() / 2,
-                    f"{prob:.1%}", va="center", fontsize=11, fontweight="bold")
-
-    ax.spines["top"].set_visible(False)
-    ax.spines["right"].set_visible(False)
-    ax.grid(axis="x", alpha=0.3, linestyle="--")
-    fig.tight_layout()
+    ax.set_yticklabels(names, fontweight="medium")
+    ax.set_xlim(0, 1.12)
+    ax.set_xlabel("Probability")
+    ax.grid(axis="x", alpha=0.15, linestyle="-", zorder=0)
+    ax.set_axisbelow(True)
+
+    for bar, prob in zip(bars, probs):
+        if prob > 0.03:
+            ax.text(bar.get_width() + 0.015,
+                    bar.get_y() + bar.get_height() / 2,
+                    f"{prob:.1%}", va="center", fontsize=10,
+                    fontweight="bold", color=PAL["dark"])
+
+    fig.tight_layout(pad=1.0)
     return fig
 
 
 def plot_posteriors(samples, param_names, mechanism_name, domain="ec"):
-    """
-    Violin plots of posterior distributions for each parameter.
-
-    Args:
-        samples: [n_samples, D] array of posterior samples
-        param_names: list of parameter names
-        mechanism_name: name of the mechanism
-        domain: 'ec' or 'tpd'
-
-    Returns:
-        matplotlib Figure
-    """
+    """KDE + rug plots of posterior distributions for each parameter."""
+    from scipy.stats import gaussian_kde
+
     n_params = len(param_names)
-    fig, axes = plt.subplots(1, n_params, figsize=(max(4, 3 * n_params), 4.5))
+    fig, axes = plt.subplots(1, n_params,
+                             figsize=(max(4, 2.8 * n_params), 3.2))
     if n_params == 1:
         axes = [axes]
 
     colors = MECH_COLORS_EC if domain == "ec" else MECH_COLORS_TPD
-    color = colors.get(mechanism_name, COLORS["primary"])
+    color = colors.get(mechanism_name, PAL["blue"])
 
     for i, (ax, name) in enumerate(zip(axes, param_names)):
         data = samples[:, i]
-
-        parts = ax.violinplot(data, positions=[0], showmeans=True,
-                              showmedians=True, showextrema=False)
-        for pc in parts["bodies"]:
-            pc.set_facecolor(color)
-            pc.set_alpha(0.6)
-        parts["cmeans"].set_color("black")
-        parts["cmedians"].set_color(COLORS["warm"])
-
-        q05, q95 = np.quantile(data, [0.05, 0.95])
-        ax.axhline(q05, color=COLORS["neutral"], linestyle="--", alpha=0.5, linewidth=0.8)
-        ax.axhline(q95, color=COLORS["neutral"], linestyle="--", alpha=0.5, linewidth=0.8)
-
-        ax.set_title(_format_param_name(name), fontsize=11, fontweight="medium")
-        ax.set_xticks([])
-        ax.spines["top"].set_visible(False)
-        ax.spines["right"].set_visible(False)
-        ax.spines["bottom"].set_visible(False)
-
-        mean_val = data.mean()
-        ax.text(0.5, 0.02, f"mean={mean_val:.3f}", transform=ax.transAxes,
-                ha="center", fontsize=9, color=COLORS["neutral"])
-
-    fig.suptitle(f"Parameter Posteriors — {mechanism_name}",
-                 fontsize=14, fontweight="bold")
-    fig.tight_layout(rect=[0, 0, 1, 0.93])
+        q05, q50, q95 = np.quantile(data, [0.05, 0.5, 0.95])
+
+        try:
+            kde = gaussian_kde(data, bw_method="silverman")
+            xs = np.linspace(data.min() - 0.1 * data.ptp(),
+                             data.max() + 0.1 * data.ptp(), 300)
+            ys = kde(xs)
+            ax.fill_between(xs, ys, alpha=0.25, color=color, zorder=2)
+            ax.plot(xs, ys, color=color, linewidth=1.8, zorder=3)
+        except Exception:
+            ax.hist(data, bins=40, density=True, color=color, alpha=0.4)
+
+        ax.axvline(q50, color=PAL["dark"], linewidth=1.2, linestyle="-",
+                   label=f"median {q50:.3f}", zorder=4)
+        ax.axvspan(q05, q95, alpha=0.08, color=color, zorder=1)
+
+        n_rug = min(len(data), 200)
+        rug_idx = np.random.choice(len(data), n_rug, replace=False)
+        ax.plot(data[rug_idx], np.zeros(n_rug) - 0.02 * ax.get_ylim()[1],
+                "|", color=color, alpha=0.3, markersize=4, zorder=2)
+
+        ax.set_xlabel(_format_param_name(name))
+        ax.set_yticks([])
+        ax.spines["left"].set_visible(False)
+
+        ax.text(0.97, 0.95,
+                f"median {q50:.3f}\n90% CI [{q05:.3f}, {q95:.3f}]",
+                transform=ax.transAxes, fontsize=7.5, va="top", ha="right",
+                color=PAL["dark"], alpha=0.7,
+                bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="none", alpha=0.8))
+
+    fig.suptitle(f"Posterior Distributions — {mechanism_name}",
+                 fontsize=13, fontweight="bold", y=1.02)
+    fig.tight_layout(pad=0.8)
     return fig
 
 
 def plot_reconstruction(observed_curves, recon_curves, domain="ec",
                         nrmses=None, r2s=None, scan_labels=None):
-    """
-    Overlay of observed vs reconstructed signals with optional metrics.
-
-    Args:
-        observed_curves: list of dicts with 'x' and 'y' arrays
-        recon_curves: list of dicts with 'x' and 'y' arrays (same length)
-        domain: 'ec' or 'tpd'
-        nrmses: optional list of NRMSE values per curve
-        r2s: optional list of R2 values per curve
-        scan_labels: optional list of label strings per curve
-
-    Returns:
-        matplotlib Figure
-    """
+    """Overlay of observed vs reconstructed signals."""
     n_curves = len(observed_curves)
-    fig, axes = plt.subplots(1, min(n_curves, 4),
-                             figsize=(max(5, 4 * min(n_curves, 4)), 5),
+    ncols = min(n_curves, 3)
+    fig, axes = plt.subplots(1, ncols,
+                             figsize=(max(4.5, 4 * ncols), 3.8),
                              squeeze=False)
     axes = axes[0]
 
@@ -167,61 +165,46 @@ def plot_reconstruction(observed_curves, recon_curves, domain="ec",
         obs = observed_curves[i]
         rec = recon_curves[i]
 
-        ax.plot(obs["x"], obs["y"], color=COLORS["neutral"], linewidth=1.5,
-                label="Observed", alpha=0.8)
-        ax.plot(rec["x"], rec["y"], color=COLORS["primary"], linewidth=1.5,
-                label="Reconstructed", linestyle="--")
+        ax.plot(obs["x"], obs["y"], color=PAL["gray"], linewidth=1.6,
+                label="Observed", alpha=0.85, zorder=2)
+        ax.plot(rec["x"], rec["y"], color=PAL["blue"], linewidth=1.6,
+                label="Reconstructed", linestyle="--", zorder=3)
 
-        ax.set_xlabel(xlabel, fontsize=10)
+        ax.set_xlabel(xlabel)
         if i == 0:
-            ax.set_ylabel(ylabel, fontsize=10)
-        ax.legend(fontsize=8, framealpha=0.8, loc="best")
-        ax.spines["top"].set_visible(False)
-        ax.spines["right"].set_visible(False)
-
-        if scan_labels and i < len(scan_labels):
-            title = scan_labels[i]
-        elif domain == "ec":
-            title = f"Scan rate {i + 1}"
-        else:
-            title = f"Heating rate {i + 1}"
-        ax.set_title(title, fontsize=10)
+            ax.set_ylabel(ylabel)
+        ax.legend(framealpha=0.9, loc="best", handlelength=1.5)
 
-        metrics_parts = []
+        title = (scan_labels[i] if scan_labels and i < len(scan_labels)
+                 else f"Curve {i + 1}")
+        ax.set_title(title)
+
+        parts = []
         if nrmses and i < len(nrmses) and np.isfinite(nrmses[i]):
-            metrics_parts.append(f"NRMSE={nrmses[i]:.4f}")
+            parts.append(f"NRMSE {nrmses[i]:.4f}")
         if r2s and i < len(r2s) and np.isfinite(r2s[i]):
-            metrics_parts.append(f"R\u00b2={r2s[i]:.4f}")
-        if metrics_parts:
-            ax.text(0.02, 0.98, "  ".join(metrics_parts),
+            parts.append(f"R\u00b2 {r2s[i]:.4f}")
+        if parts:
+            ax.text(0.03, 0.97, "  |  ".join(parts),
                     transform=ax.transAxes, fontsize=8, va="top",
-                    color=COLORS["accent"], fontweight="bold",
-                    bbox=dict(boxstyle="round,pad=0.3", facecolor="white",
-                              alpha=0.8, edgecolor=COLORS["accent"]))
-
-    suptitle = "Signal Reconstruction"
-    if nrmses and r2s:
-        valid_nrmse = [v for v in nrmses if np.isfinite(v)]
-        valid_r2 = [v for v in r2s if np.isfinite(v)]
-        if valid_nrmse and valid_r2:
-            avg_nrmse = np.mean(valid_nrmse)
-            avg_r2 = np.mean(valid_r2)
-            suptitle += f"  (avg NRMSE={avg_nrmse:.4f}, avg R\u00b2={avg_r2:.4f})"
-
-    fig.suptitle(suptitle, fontsize=12, fontweight="bold")
-    fig.tight_layout(rect=[0, 0, 1, 0.93])
+                    color=PAL["green"], fontweight="bold",
+                    bbox=dict(boxstyle="round,pad=0.3", fc="white",
+                              alpha=0.85, ec=PAL["green"], lw=0.6))
+
+    fig.suptitle("Signal Reconstruction", fontsize=13, fontweight="bold", y=1.02)
+    fig.tight_layout(pad=0.8)
     return fig
 
 
 def _add_sweep_arrows(ax, pot, y_ox, y_red, mid):
-    """Add direction arrows and labels for forward/reverse sweeps on both species."""
+    """Add direction arrows for forward/reverse sweeps."""
     sweep_specs = [
         (slice(None, mid), "reductive \u2192", 16),
         (slice(mid, None), "\u2190 oxidative", -16),
     ]
     curves = [
-        (y_ox, COLORS["primary"], 0.35, 0.65),
-        (y_red, COLORS["warm"], 0.35, 0.65),
+        (y_ox, PAL["blue"], 0.35, 0.65),
+        (y_red, PAL["red"], 0.35, 0.65),
     ]
     for y_data, color, fwd_frac, rev_frac in curves:
         for segment, label, y_offset in sweep_specs:
@@ -232,9 +215,7 @@ def _add_sweep_arrows(ax, pot, y_ox, y_red, mid):
                 continue
 
             frac = fwd_frac if y_offset > 0 else rev_frac
-            idx = int(n * frac)
-            idx = max(2, min(idx, n - 3))
-
+            idx = max(2, min(int(n * frac), n - 3))
             step = max(1, n // 30)
             i0 = max(0, idx - step)
             i1 = min(n - 1, idx + step)
@@ -243,34 +224,24 @@ def _add_sweep_arrows(ax, pot, y_ox, y_red, mid):
                 "", xy=(x_seg[i1], y_seg[i1]),
                 xytext=(x_seg[i0], y_seg[i0]),
                 arrowprops=dict(arrowstyle="-|>", color=color,
-                                lw=1.8, mutation_scale=14),
+                                lw=1.6, mutation_scale=12),
             )
-
             ax.annotate(label, xy=(x_seg[idx], y_seg[idx]),
                         xytext=(0, y_offset), textcoords="offset points",
-                        fontsize=7.5, color=color, fontstyle="italic",
+                        fontsize=7, color=color, fontstyle="italic",
                         ha="center", va="center")
 
 
 def plot_concentration_profiles(conc_curves, scan_labels=None):
-    """
-    Plot surface concentration profiles (C_A and C_B) vs potential.
-
-    Args:
-        conc_curves: list of dicts with 'x' (potential), 'c_ox', 'c_red',
-                     or None for failed reconstructions
-        scan_labels: optional list of label strings per curve
-
-    Returns:
-        matplotlib Figure, or None if no valid data
-    """
+    """Plot surface concentration profiles vs potential."""
     valid = [c for c in conc_curves if c is not None]
     if not valid:
         return None
 
     n_curves = len(conc_curves)
-    fig, axes = plt.subplots(1, min(n_curves, 4),
-                             figsize=(max(5, 4 * min(n_curves, 4)), 5),
+    ncols = min(n_curves, 3)
+    fig, axes = plt.subplots(1, ncols,
+                             figsize=(max(4.5, 4 * ncols), 3.8),
                              squeeze=False)
     axes = axes[0]
 
@@ -285,46 +256,29 @@ def plot_concentration_profiles(conc_curves, scan_labels=None):
         c_red = np.asarray(c["c_red"])
         mid = len(pot) // 2
 
-        # Forward sweep (reductive): first half
-        ax.plot(pot[:mid], c_ox[:mid], color=COLORS["primary"], linewidth=1.5,
-                label="C$_A$ (ox)")
-        ax.plot(pot[:mid], c_red[:mid], color=COLORS["warm"], linewidth=1.5,
-                label="C$_B$ (red)")
-        # Reverse sweep (oxidative): second half
-        ax.plot(pot[mid:], c_ox[mid:], color=COLORS["primary"], linewidth=1.5)
-        ax.plot(pot[mid:], c_red[mid:], color=COLORS["warm"], linewidth=1.5)
+        ax.plot(pot[:mid], c_ox[:mid], color=PAL["blue"], lw=1.5, label="C$_A$ (ox)")
+        ax.plot(pot[:mid], c_red[:mid], color=PAL["red"], lw=1.5, label="C$_B$ (red)")
+        ax.plot(pot[mid:], c_ox[mid:], color=PAL["blue"], lw=1.5)
+        ax.plot(pot[mid:], c_red[mid:], color=PAL["red"], lw=1.5)
 
         _add_sweep_arrows(ax, pot, c_ox, c_red, mid)
 
-        ax.set_xlabel("Potential (\u03b8)", fontsize=10)
+        ax.set_xlabel("Potential (\u03b8)")
         if i == 0:
-            ax.set_ylabel("Surface concentration", fontsize=10)
-        ax.legend(fontsize=8, framealpha=0.8, loc="best")
-        ax.spines["top"].set_visible(False)
-        ax.spines["right"].set_visible(False)
+            ax.set_ylabel("Surface concentration")
+        ax.legend(framealpha=0.9, loc="best", handlelength=1.5)
 
-        if scan_labels and i < len(scan_labels):
-            ax.set_title(scan_labels[i], fontsize=10)
-        else:
-            ax.set_title(f"Scan rate {i + 1}", fontsize=10)
+        title = (scan_labels[i] if scan_labels and i < len(scan_labels)
+                 else f"Curve {i + 1}")
+        ax.set_title(title)
 
-    fig.suptitle("Surface Concentration Profiles", fontsize=12,
-                 fontweight="bold")
-    fig.tight_layout(rect=[0, 0, 1, 0.93])
+    fig.suptitle("Surface Concentration Profiles", fontsize=13, fontweight="bold", y=1.02)
+    fig.tight_layout(pad=0.8)
     return fig
 
 
 def plot_parameter_table(param_stats, mechanism_name):
-    """
-    Create a formatted parameter summary table as a figure.
-
-    Args:
-        param_stats: dict with 'names', 'mean', 'std', 'q05', 'q95'
-        mechanism_name: name of the mechanism
-
-    Returns:
-        matplotlib Figure
-    """
+    """Create a formatted parameter summary table as a figure."""
     names = param_stats["names"]
     means = param_stats["mean"]
     stds = param_stats["std"]
@@ -332,35 +286,33 @@ def plot_parameter_table(param_stats, mechanism_name):
     q95s = param_stats["q95"]
 
     n = len(names)
-    fig, ax = plt.subplots(figsize=(8, max(2, 0.6 * n + 1)))
+    fig, ax = plt.subplots(figsize=(7, max(1.8, 0.5 * n + 0.8)))
     ax.axis("off")
 
     col_labels = ["Parameter", "Mean", "Std", "5th %ile", "95th %ile"]
-    cell_text = []
-    for i in range(n):
-        cell_text.append([
-            _format_param_name(names[i]),
-            f"{means[i]:.4f}",
-            f"{stds[i]:.4f}",
-            f"{q05s[i]:.4f}",
-            f"{q95s[i]:.4f}",
-        ])
+    cell_text = [
+        [_format_param_name(names[i]),
+         f"{means[i]:.4f}", f"{stds[i]:.4f}",
+         f"{q05s[i]:.4f}", f"{q95s[i]:.4f}"]
+        for i in range(n)
+    ]
 
     table = ax.table(cellText=cell_text, colLabels=col_labels,
                      loc="center", cellLoc="center")
     table.auto_set_font_size(False)
-    table.set_fontsize(11)
-    table.scale(1.0, 1.5)
+    table.set_fontsize(10)
+    table.scale(1.0, 1.4)
 
     for (row, col), cell in table.get_celld().items():
+        cell.set_edgecolor("#E5E7EB")
         if row == 0:
-            cell.set_facecolor("#E5E7EB")
+            cell.set_facecolor("#EEF2FF")
             cell.set_text_props(fontweight="bold")
         else:
-            cell.set_facecolor("#F9FAFB" if row % 2 == 0 else "white")
+            cell.set_facecolor("white" if row % 2 else "#F9FAFB")
 
     ax.set_title(f"Parameter Estimates — {mechanism_name}",
-                 fontsize=14, fontweight="bold", pad=20)
+                 fontsize=13, fontweight="bold", pad=16)
     fig.tight_layout()
     return fig
 
@@ -368,29 +320,29 @@ def plot_parameter_table(param_stats, mechanism_name):
 def _format_param_name(name):
     """Format parameter names for display."""
     replacements = {
-        "log10(K0)": "log₁₀(K₀)",
-        "log10(dB)": "log₁₀(d_B)",
-        "log10(dA)": "log₁₀(d_A)",
-        "log10(kc)": "log₁₀(k_c)",
-        "log10(reorg_e)": "log₁₀(λ)",
-        "log10(Gamma_sat)": "log₁₀(Γ_sat)",
-        "log10(KA_eq)": "log₁₀(K_A,eq)",
-        "log10(KB_eq)": "log₁₀(K_B,eq)",
-        "log10(nu)": "log₁₀(ν)",
-        "log10(nu_red)": "log₁₀(ν_red)",
-        "log10(D0)": "log₁₀(D₀)",
-        "E0_offset": "E₀ offset",
-        "alpha": "α",
-        "alpha_cov": "α_cov",
+        "log10(K0)": "log\u2081\u2080(K\u2080)",
+        "log10(dB)": "log\u2081\u2080(d_B)",
+        "log10(dA)": "log\u2081\u2080(d_A)",
+        "log10(kc)": "log\u2081\u2080(k_c)",
+        "log10(reorg_e)": "log\u2081\u2080(\u03bb)",
+        "log10(Gamma_sat)": "log\u2081\u2080(\u0393_sat)",
+        "log10(KA_eq)": "log\u2081\u2080(K_A,eq)",
+        "log10(KB_eq)": "log\u2081\u2080(K_B,eq)",
+        "log10(nu)": "log\u2081\u2080(\u03bd)",
+        "log10(nu_red)": "log\u2081\u2080(\u03bd_red)",
+        "log10(D0)": "log\u2081\u2080(D\u2080)",
+        "E0_offset": "E\u2080 offset",
+        "alpha": "\u03b1",
+        "alpha_cov": "\u03b1_cov",
         "Ed": "E_d (K)",
         "Ed0": "E_d0 (K)",
         "Ea": "E_a (K)",
         "Ea_red": "E_a,red (K)",
         "Ea_reox": "E_a,reox (K)",
         "E_diff": "E_diff (K)",
-        "theta_0": "θ₀",
-        "theta_A0": "θ_A0",
-        "theta_B0": "θ_B0",
-        "theta_O0": "θ_O0",
+        "theta_0": "\u03b8\u2080",
+        "theta_A0": "\u03b8_A0",
+        "theta_B0": "\u03b8_B0",
+        "theta_O0": "\u03b8_O0",
     }
     return replacements.get(name, name)