quantui 0.6.0__tar.gz → 0.6.1__tar.gz

{quantui-0.6.0 → quantui-0.6.1}/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.ht
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-08-05
+
+### Fixed
+
+- **Reorganization-energy results now survive History.** Reloading one from
+  History showed the calculation's headline numbers as missing — λ, the
+  four-point energies and the per-channel breakdown were never written to disk,
+  so there was nothing to redisplay. Both the live and History result cards now
+  render from the same saved data, so anything visible during a run is visible
+  after reloading it.
+  **Results saved before this cannot be recovered** — λ requires two geometry
+  optimizations and four SCF energies. Those results now say so on the card and
+  tell you to re-run, rather than appearing silently incomplete.
+- **3-D backgrounds follow the theme** in the new geometry viewers, matching the
+  fix applied to the other viewers in 0.6.0.
+
+### Added
+
+- **A Geometries panel** for reorganization energy, on the Analysis tab — which
+  previously showed nothing at all for this calculation type. Step through the
+  distinct geometries behind the four energies, or overlay two of them with
+  arrows marking how each atom moved. The arrows can be scaled ×1–×10 for small
+  relaxations; the structures always show true computed positions.
+- **Geometry relaxation on the result card** — RMSD and the largest single-atom
+  shift between the neutral and ion geometries, which is what λ physically
+  measures.
+- **Compare λ across saved results.** Selecting several reorganization-energy
+  runs in the Compare tab now shows a λ table with a column per channel, for
+  screening candidates by how much they reorganize.
+
+### Changed
+
+- The NCShare GPU diagnostic notebook now reports the **CPU affinity mask**
+  alongside the core count, and states plainly when CPU timings cannot be
+  trusted. A job can be granted 6 cores while still *seeing* 192; whether that
+  matters depends on how the scheduler constrains it, and the core count alone
+  cannot distinguish the two cases.
+- `apptainer/README.md` records the first verified H200 run — driver, compute
+  capability, partition, and the measured CPU/GPU crossover.
+
 ## [0.6.0] - 2026-08-04
 
 ### Added
@@ -563,7 +603,8 @@ Initial public scaffolding of the QuantUI package: `quantui` package with
 `calculator.py`, basic notebook launcher, Apptainer container definition,
 MIT license, and project metadata.
 
-[Unreleased]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.6.0...HEAD
+[Unreleased]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.6.1...HEAD
+[0.6.1]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.5.2...v0.6.0
 [0.5.2]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/The-Schultz-Lab/QuantUI/compare/v0.5.0...v0.5.1

{quantui-0.6.0/quantui.egg-info → quantui-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantui
-Version: 0.6.0
+Version: 0.6.1
 Summary: An open-source frontend for DFT and post-HF quantum chemistry with PySCF
 Author-email: Jonathan Schultz <nccu-schultz-lab@users.noreply.github.com>
 License: MIT License

{quantui-0.6.0 → quantui-0.6.1}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantui"
-version = "0.6.0"
+version = "0.6.1"
 description = "An open-source frontend for DFT and post-HF quantum chemistry with PySCF"
 readme = "README.md"
 requires-python = ">=3.9"

{quantui-0.6.0 → quantui-0.6.1}/quantui/__init__.py

@@ -7,7 +7,7 @@ Calculations run locally in the Jupyter session — no cluster or SLURM required
 PySCF requires Linux/macOS/WSL. Windows users should use the Apptainer container.
 """
 
-__version__ = "0.6.0"
+__version__ = "0.6.1"
 
 import logging
 from typing import Any

{quantui-0.6.0 → quantui-0.6.1}/quantui/app.py

@@ -45,6 +45,9 @@ from quantui.app_analysis import (
 from quantui.app_analysis import (
     deactivate_all_ana_panels as _ana_deactivate_all_ana_panels,
 )
+from quantui.app_analysis import (
+    on_reorg_view_changed as _ana_on_reorg_view_changed,
+)
 from quantui.app_analysis import (
     pop_energies as _ana_pop_energies,
 )
@@ -69,6 +72,9 @@ from quantui.app_analysis import (
 from quantui.app_analysis import (
     pop_preopt_trajectory as _ana_pop_preopt_trajectory,
 )
+from quantui.app_analysis import (
+    pop_reorg_geometries as _ana_pop_reorg_geometries,
+)
 from quantui.app_analysis import (
     pop_uv_vis as _ana_pop_uv_vis,
 )
@@ -1630,6 +1636,7 @@ class QuantUIApp:
         ("IR Spectrum", "_ir_accordion", "Frequency"),
         ("PES Scan", "_pes_scan_accordion", "PES Scan"),
         ("Isosurface", "_iso_accordion", "Single Point (Linux/WSL only)"),
+        ("Geometries", "_reorg_geom_accordion", "Reorganization Energy"),
         ("UV-Vis", "_tddft_accordion", "UV-Vis (TD-DFT)"),
         ("NMR", "_nmr_accordion", "NMR Shielding"),
     ]
@@ -1678,6 +1685,16 @@ class QuantUIApp:
         "nmr": [
             ("NMR", "_pop_nmr_shielding", True),
         ],
+        # reorganization_energy had NO entry at all until 2026-08-05, so the
+        # Analysis tab populated nothing for these runs — not a missing panel,
+        # no panels. Order matters twice over: the FIRST auto_select=True that
+        # returns True wins, AND _pop_energies loads the orbital state
+        # _pop_isosurface checks, so Energies must precede Isosurface.
+        "reorganization_energy": [
+            ("Energies", "_pop_energies", False),
+            ("Geometries", "_pop_reorg_geometries", True),
+            ("Isosurface", "_pop_isosurface", False),
+        ],
         "pes_scan": [
             ("PES Scan", "_pop_pes_plot", True),
             ("Trajectory", "_pop_pes_trajectory", False),
@@ -1693,6 +1710,9 @@ class QuantUIApp:
     def _pop_energies(self, ctx: _AnalysisContext) -> bool:
         return _ana_pop_energies(self, ctx)
 
+    def _pop_reorg_geometries(self, ctx: _AnalysisContext) -> bool:
+        return _ana_pop_reorg_geometries(self, ctx)
+
     def _pop_isosurface(self, ctx: _AnalysisContext) -> bool:
         return _ana_pop_isosurface(self, ctx)
 
@@ -2014,6 +2034,14 @@ class QuantUIApp:
         # Cube + bundle exports
         self._iso_export_cube_btn.on_click(self._on_iso_export_cube)
         self._iso_cancel_btn.on_click(self._safe_cb(self._on_iso_cancel))
+        # Reorg geometry views (REORG.3): both redraw from data already in
+        # memory, so they respond directly rather than behind an Apply button.
+        for _w in (
+            self._reorg_view_toggle,
+            self._reorg_overlay_pair,
+            self._reorg_exaggerate,
+        ):
+            _w.observe(self._safe_cb(self._on_reorg_view_changed), names="value")
         # PNG capture arrives from the browser, so there is no button to bind
         # here — the viewer's own Save-PNG button posts into this Textarea and
         # ipywidgets syncs it back, firing this observer (ORBX.1).
@@ -3378,6 +3406,9 @@ class QuantUIApp:
     def _on_export_pdb(self, btn) -> None:
         _exp_on_export_pdb(self, btn)
 
+    def _on_reorg_view_changed(self, change) -> None:
+        _ana_on_reorg_view_changed(self, change)
+
     def _on_iso_cancel(self, btn) -> None:
         _viz_on_iso_cancel(self, btn)
 

{quantui-0.6.0 → quantui-0.6.1}/quantui/app_analysis.py

@@ -253,6 +253,110 @@ def pop_energies(app: Any, ctx: Any) -> bool:
     return bool(app._show_orbital_diagram(result))
 
 
+def pop_reorg_geometries(app: Any, ctx: Any) -> bool:
+    """Populate the Geometries panel for a reorganization-energy result.
+
+    Works from a live result OR a saved one by reading the same channel payload
+    both now carry — the shape REORG.1 introduced. That is deliberate: the
+    original bug was two paths reading different things, so this one never had
+    the chance to grow a second reader.
+
+    Returns False when the payload is absent, which is exactly the pre-REORG.1
+    case; the panel then stays unavailable rather than showing an empty viewer,
+    and the results card explains why.
+    """
+    channels, neutral = _reorg_payload(app, ctx)
+    if not channels or not neutral:
+        _set_panel_unavailable_message(
+            app,
+            "Geometries",
+            (
+                "Not available for this result: the per-channel geometries were "
+                "not saved. Re-run the calculation to enable the comparison."
+            ),
+        )
+        return False
+
+    from quantui.reorganization_energy import reorg_geometries
+
+    geoms = reorg_geometries(channels, neutral)
+    if len(geoms) < 2:
+        return False
+    app._reorg_geometries = geoms
+    app._reorg_overlay_pair.options = [
+        (f"{geoms[0]['label'].split(' — ')[0]} vs {g['label'].split(' — ')[0]}", i)
+        for i in range(1, len(geoms))
+        for g in [geoms[i]]
+    ]
+    if app._reorg_overlay_pair.options:
+        app._reorg_overlay_pair.value = app._reorg_overlay_pair.options[0][1]
+    render_reorg_geometries(app)
+    return True
+
+
+def _reorg_payload(app: Any, ctx: Any) -> tuple[list, dict]:
+    """Channel list + neutral geometry, from a live result or a saved one."""
+    live = getattr(ctx, "live_result", None)
+    if live is not None and getattr(live, "channels", None):
+        from quantui.results_storage import _reorg_channels_payload
+
+        payload = _reorg_channels_payload(live) or []
+        neutral = payload[0].get("neutral_geometry") if payload else None
+        return payload, neutral or {}
+
+    result_dir = getattr(ctx, "result_dir", None)
+    if result_dir is not None:
+        try:
+            from quantui import load_result
+
+            data = load_result(result_dir)
+            payload = data.get("reorg_channels") or []
+            neutral = payload[0].get("neutral_geometry") if payload else None
+            return payload, neutral or {}
+        except Exception:  # noqa: BLE001 — a missing panel, never a crash
+            return [], {}
+    return [], {}
+
+
+def render_reorg_geometries(app: Any) -> None:
+    """Draw the current view (stepper or overlay) into the Geometries panel."""
+    geoms = getattr(app, "_reorg_geometries", None)
+    if not geoms:
+        return
+    from quantui.app_visualization import (
+        build_reorg_geometry_viewer_html,
+        build_reorg_overlay_html,
+    )
+
+    bg = app._plotly_theme_colors()["scene_bgcolor"]
+    try:
+        if app._reorg_view_toggle.value == "overlay":
+            idx = int(app._reorg_overlay_pair.value or 1)
+            html = build_reorg_overlay_html(
+                geoms[0],
+                geoms[idx],
+                bgcolor=bg,
+                exaggerate=float(getattr(app._reorg_exaggerate, "value", 1.0)),
+            )
+        else:
+            html = build_reorg_geometry_viewer_html(geoms, bgcolor=bg)
+        app._set_html_output(app._reorg_geom_output, html)
+    except Exception as exc:  # noqa: BLE001
+        app._set_html_output(
+            app._reorg_geom_output,
+            f'<p style="color:#b91c1c;padding:8px">Geometry view failed: {exc}</p>',
+        )
+
+
+def on_reorg_view_changed(app: Any, change: Any = None) -> None:
+    """Toggle between stepper and overlay; the pair picker only applies to one."""
+    is_overlay = app._reorg_view_toggle.value == "overlay"
+    app._reorg_overlay_pair.layout.display = "" if is_overlay else "none"
+    # Only meaningful for the overlay — the stepper shows true positions.
+    app._reorg_exaggerate.layout.display = "" if is_overlay else "none"
+    render_reorg_geometries(app)
+
+
 def pop_isosurface(app: Any, ctx: Any) -> bool:
     """Populate Isosurface availability from orbital state.
 

{quantui-0.6.0 → quantui-0.6.1}/quantui/app_builders.py

@@ -2073,6 +2073,58 @@ def build_results_section(app: Any, *, layout_fn: Any) -> None:
     app._iso_accordion.set_title(0, "Orbital Isosurface")
     app._iso_accordion.selected_index = None
 
+    # ── Reorganization-energy geometries (M-REORG REORG.3) ──────────────
+    # Two views of the same data, because they answer different questions:
+    # stepping shows what each geometry looks like, overlaying shows what
+    # MOVED — and displacement is what λ actually measures.
+    app._reorg_geom_output = widgets.Output(
+        layout=layout_fn(min_height="470px", overflow="hidden")
+    )
+    app._reorg_view_toggle = widgets.ToggleButtons(
+        options=[("Step through", "step"), ("Overlay", "overlay")],
+        value="step",
+        style={"button_width": "120px"},
+        layout=layout_fn(margin="0 0 6px 0"),
+    )
+    app._reorg_overlay_pair = widgets.Dropdown(
+        options=[],
+        description="Compare:",
+        style={"description_width": "70px"},
+        layout=layout_fn(width="380px", display="none"),
+    )
+    # λ relaxations are often a few hundredths of an Ångström — real, and
+    # invisible at 1:1. Scaling the ARROWS (never the structures) is the same
+    # convention vibrational-mode displays use, so nothing shown is fictional.
+    app._reorg_exaggerate = widgets.Dropdown(
+        options=[("True scale (×1)", 1.0), ("×3", 3.0), ("×5", 5.0), ("×10", 10.0)],
+        value=1.0,
+        description="Arrows:",
+        style={"description_width": "70px"},
+        layout=layout_fn(width="380px", display="none"),
+    )
+    app._reorg_geom_body = widgets.VBox(
+        [
+            widgets.HTML(
+                '<p style="color:#555;font-size:12px;margin:0 0 8px">'
+                "The Marcus 4-point scheme evaluates <b>four energies on two "
+                "geometries per channel</b> — the optimized neutral and the "
+                "optimized ion. λ is how far the molecule relaxed between "
+                "them.</p>"
+            ),
+            app._reorg_view_toggle,
+            app._reorg_overlay_pair,
+            app._reorg_exaggerate,
+            app._reorg_geom_output,
+        ],
+        layout=layout_fn(padding="8px"),
+    )
+    app._reorg_geom_accordion = widgets.Accordion(
+        children=[app._reorg_geom_body],
+        layout=layout_fn(display="none", margin="8px 0"),
+    )
+    app._reorg_geom_accordion.set_title(0, "Geometries (λ relaxation)")
+    app._reorg_geom_accordion.selected_index = None
+
     app._uv_mode_toggle = widgets.ToggleButtons(
         options=["Stick", "Broadened"],
         value="Stick",
@@ -2281,6 +2333,11 @@ def build_results_section(app: Any, *, layout_fn: Any) -> None:
             app.vib_accordion,
             app._ir_accordion,
             app._iso_accordion,
+            # Creating the accordion and registering it in _PANEL_META is not
+            # enough — it also has to be a child of this VBox or it can never
+            # render. Missed on the first pass (2026-08-05): the panel existed,
+            # the registry knew about it, and the Analysis tab showed nothing.
+            app._reorg_geom_accordion,
             app._tddft_accordion,
             app._nmr_accordion,
         ]

{quantui-0.6.0 → quantui-0.6.1}/quantui/app_formatters.py

@@ -367,36 +367,260 @@ def format_pes_scan_result(r: Any) -> str:
     )
 
 
-def format_reorg_result(r: Any) -> str:
-    """Format a reorganization-energy (Marcus 4-point) result card."""
-    _conv = "Yes" if r.converged else "No (some steps did not converge)"
-    _cc = "green" if r.converged else "#c00"
+_HARTREE_TO_EV = 27.211386245988
+_HARTREE_TO_KCAL = 627.509474
 
-    def _channel_block(ch: Any) -> str:
-        rows = "".join(
-            f'<tr><td style="padding:2px 18px 2px 0;color:#444">{k}</td>'
-            f'<td style="color:#000;font-family:monospace">{v}</td></tr>'
-            for k, v in [
-                ("λ", f"{ch.lambda_ev:.4f} eV ({ch.lambda_kcal:.2f} kcal/mol)"),
-                ("λ₁ ion relaxation", f"{ch.lambda1_hartree * 27.211386245988:.4f} eV"),
-                (
-                    "λ₂ neutral relaxation",
-                    f"{ch.lambda2_hartree * 27.211386245988:.4f} eV",
-                ),
+
+def _attach_relaxation_from_saved(payload: list[dict], data: dict) -> None:
+    """RMSD/displacement for a result loaded from disk.
+
+    The neutral geometry comes from the saved molecule rather than a live
+    result object; everything downstream is the same computation the live card
+    does, so the two cards report identical numbers.
+    """
+    from quantui.molecule import Molecule
+
+    # The neutral geometry travels inside the channel payload — see
+    # _reorg_channels_payload for why it is not read from the top level.
+    geom = next(
+        (c.get("neutral_geometry") for c in payload if c.get("neutral_geometry")), None
+    )
+    if not geom:
+        return
+    try:
+        neutral = Molecule(
+            atoms=list(geom["atoms"]),
+            coordinates=[list(c) for c in geom["coordinates"]],
+            charge=geom.get("charge", 0),
+            multiplicity=geom.get("multiplicity", 1),
+        )
+    except Exception:  # noqa: BLE001 — never break a history card
+        return
+
+    class _Holder:
+        molecule = neutral
+
+    _attach_relaxation(payload, _Holder())
+
+
+def _attach_relaxation(payload: list[dict], result: Any = None) -> None:
+    """Add RMSD / largest-atom-shift to each channel, in place (REORG.4).
+
+    Computed at DISPLAY time from geometries that are already stored, rather
+    than persisted as another number that could drift out of step with the
+    coordinates it describes.
+    """
+    from quantui.molecule import Molecule
+    from quantui.reorganization_energy import geometry_rmsd, max_atom_displacement
+
+    neutral = getattr(result, "molecule", None) if result is not None else None
+    for entry in payload:
+        geom = entry.get("ion_geometry")
+        if neutral is None or not geom:
+            continue
+        try:
+            ion = Molecule(
+                atoms=list(geom["atoms"]),
+                coordinates=[list(c) for c in geom["coordinates"]],
+                charge=geom.get("charge", 0),
+                multiplicity=geom.get("multiplicity", 1),
+            )
+        except Exception:  # noqa: BLE001 — a readout must not break a card
+            continue
+        rmsd = geometry_rmsd(neutral, ion)
+        if rmsd is None:
+            continue
+        entry["relaxation"] = {
+            "rmsd": rmsd,
+            "max_atom": max_atom_displacement(neutral, ion),
+        }
+
+
+def reorg_comparison_html(entries: list[tuple[str, dict]]) -> str:
+    """Side-by-side λ table for several saved reorganization-energy results.
+
+    ``entries`` is ``[(label, loaded_result_dict), ...]``.
+
+    This is the workflow reorganization energy exists for: screening candidate
+    molecules by how much they reorganize. One λ in isolation is hard to judge —
+    it is only meaningful against other candidates — so a comparison view is
+    arguably the point of the calculation rather than a nicety.
+
+    Rendered as its own table rather than as extra columns on the general
+    comparison: λ is per-CHANNEL (hole and electron), so it does not fit a
+    one-row-per-result grid without either duplicating rows or inventing a
+    combined number that has no physical meaning.
+
+    Results with no channel payload are listed with a note rather than skipped —
+    silently omitting them would look like they were never selected.
+    """
+    if not entries:
+        return ""
+
+    kinds: list[str] = []
+    for _, data in entries:
+        for ch in data.get("reorg_channels") or []:
+            if ch.get("kind") and ch["kind"] not in kinds:
+                kinds.append(ch["kind"])
+    if not kinds:
+        return ""
+
+    # theme.BORDER, not a hand-picked grey. Dark mode is a whole-page colour
+    # inversion, so a light grey rule inverts to near-black on a near-black page
+    # and vanishes — the defect THEME.5 fixed, and which this table reintroduced
+    # until test_retired_border_greys_are_gone_from_in_app_chrome caught it.
+    th = f"text-align:left;padding:6px 12px;border-bottom:2px solid {_theme.BORDER}"
+    td = f"padding:5px 12px;border-bottom:1px solid {_theme.BORDER}"
+    head = (
+        f'<th style="{th}">Result</th><th style="{th}">Method / basis</th>'
+        + "".join(f'<th style="{th}">λ {k} (eV)</th>' for k in kinds)
+        + f'<th style="{th}">Relaxation (Å)</th>'
+    )
+
+    rows = []
+    for label, data in entries:
+        channels = data.get("reorg_channels") or []
+        if not channels:
+            rows.append(
+                f'<tr><td style="{td}">{label}</td>'
+                f'<td style="{td}" colspan="{len(kinds) + 2}">'
+                '<span style="color:#92400e">λ not saved — re-run to compare'
+                "</span></td></tr>"
+            )
+            continue
+        _attach_relaxation_from_saved(channels, data)
+        by_kind = {c.get("kind"): c for c in channels}
+        cells = []
+        for k in kinds:
+            ch = by_kind.get(k)
+            lam = ch.get("lambda_hartree") if ch else None
+            cells.append(
+                f'<td style="{td};font-family:monospace">'
+                + ("—" if lam is None else f"{lam * _HARTREE_TO_EV:.4f}")
+                + "</td>"
+            )
+        rmsds = [c["relaxation"]["rmsd"] for c in channels if c.get("relaxation")]
+        relax = f"{max(rmsds):.4f}" if rmsds else "—"
+        rows.append(
+            f'<tr><td style="{td}">{label}</td>'
+            f'<td style="{td}">{data.get("method", "?")}/{data.get("basis", "?")}</td>'
+            + "".join(cells)
+            + f'<td style="{td};font-family:monospace">{relax}</td></tr>'
+        )
+
+    return (
+        '<div style="margin-top:14px">'
+        '<h4 style="margin:0 0 4px">Reorganization energy</h4>'
+        '<p style="color:#555;font-size:12px;margin:0 0 6px">'
+        "Lower λ means less geometric reorganization on charging — generally "
+        "favourable for charge transport. Relaxation is the largest per-channel "
+        "RMSD between the neutral and ion geometries.</p>"
+        '<table style="border-collapse:collapse;font-size:13px">'
+        f"<tr>{head}</tr>{''.join(rows)}</table></div>"
+    )
+
+
+def reorg_channels_html(channels: list[dict]) -> str:
+    """Render reorganization-energy channels from PLAIN DATA.
+
+    Both the live card and the History card go through here. They used to have
+    separate implementations — the live one reading attributes off a result
+    object, the history one having no channels at all — which is precisely how
+    the reported bug arose. A single renderer over plain dicts is what stops
+    them drifting again: the live path converts its objects to the same shape
+    the saved file holds, so anything that renders live renders after reload.
+    """
+    if not channels:
+        return ""
+
+    def _label(kind: str) -> str:
+        return {
+            "hole": "Hole transfer (cation)",
+            "electron": "Electron transfer (anion)",
+        }.get(kind, str(kind).title())
+
+    blocks = []
+    for ch in channels:
+        lam = ch.get("lambda_hartree")
+        rows = [
+            (
+                "λ",
                 (
-                    "Ion state",
-                    f"charge {ch.ion_charge:+d}, mult {ch.ion_multiplicity}",
+                    "—"
+                    if lam is None
+                    else f"{lam * _HARTREE_TO_EV:.4f} eV "
+                    f"({lam * _HARTREE_TO_KCAL:.2f} kcal/mol)"
                 ),
-            ]
+            ),
+            ("λ₁ ion relaxation", _ev(ch.get("lambda1_hartree"))),
+            ("λ₂ neutral relaxation", _ev(ch.get("lambda2_hartree"))),
+            (
+                "Ion state",
+                f"charge {ch.get('ion_charge', 0):+d}, "
+                f"mult {ch.get('ion_multiplicity', '?')}",
+            ),
+        ]
+        # Geometry relaxation (REORG.4): what λ physically measures. Only
+        # present once the ion geometry is saved, so older results simply omit
+        # these rows rather than showing blanks.
+        relax = ch.get("relaxation")
+        if relax:
+            rows.append(("Geometry RMSD", f"{relax['rmsd']:.4f} Å"))
+            if relax.get("max_atom") is not None:
+                idx, dist = relax["max_atom"]
+                rows.append(("Largest atom shift", f"{dist:.4f} Å (atom {idx + 1})"))
+        body = "".join(
+            f'<tr><td style="padding:2px 18px 2px 0;color:#444">{k}</td>'
+            f'<td style="color:#000;font-family:monospace">{v}</td></tr>'
+            for k, v in rows
         )
-        return (
+        blocks.append(
             f'<div style="margin-top:8px">'
-            f'<b style="font-size:13px;color:#166534">{ch.label}</b>'
+            f'<b style="font-size:13px;color:#166534">{_label(ch.get("kind", ""))}</b>'
             f'<table style="margin-top:2px;font-size:13px;border-collapse:collapse">'
-            f"{rows}</table></div>"
+            f"{body}</table></div>"
         )
+    return "".join(blocks)
+
+
+def _ev(hartree: Any) -> str:
+    return "—" if hartree is None else f"{hartree * _HARTREE_TO_EV:.4f} eV"
+
 
-    _channels_html = "".join(_channel_block(ch) for ch in r.channels)
+def reorg_missing_data_notice() -> str:
+    """Shown on a reorganization-energy result saved before REORG.1.
+
+    Those runs never wrote their channel data, and it cannot be recovered — λ
+    is two geometry optimizations and four SCF energies. So the card says so
+    and names the remedy, rather than rendering an empty section that reads
+    like a rendering failure.
+
+    Detected by ABSENCE of the payload, not by version or timestamp: a result
+    re-saved or imported from elsewhere would defeat a version cutoff.
+    """
+    return (
+        '<div style="margin-top:8px;padding:8px 10px;border-radius:6px;'
+        'background:#fef3c7;border:1px solid #f59e0b;font-size:13px;color:#78350f">'
+        "<b>⚠ Reorganization-energy details were not saved for this result.</b><br>"
+        "Results produced before QuantUI gained λ persistence did not store the "
+        "per-channel energies or geometries, and they cannot be recovered from "
+        "what was saved. <b>Re-run this calculation</b> to see the λ breakdown, "
+        "the four-point energies and the geometry comparison."
+        "</div>"
+    )
+
+
+def format_reorg_result(r: Any) -> str:
+    """Format a reorganization-energy (Marcus 4-point) result card."""
+    _conv = "Yes" if r.converged else "No (some steps did not converge)"
+    _cc = "green" if r.converged else "#c00"
+
+    # Same renderer, same shape as the saved payload — see reorg_channels_html.
+    from quantui.results_storage import _reorg_channels_payload
+
+    _payload = _reorg_channels_payload(r) or []
+    _attach_relaxation(_payload, r)
+    _channels_html = reorg_channels_html(_payload)
     return (
         f'<div style="background:#f0fff0;border-left:4px solid #4CAF50;'
         f'padding:10px 14px;border-radius:4px;margin:6px 0">'
@@ -483,6 +707,19 @@ def format_past_result(data: dict[str, Any], result_dir: Optional[Path] = None)
                 f'border:1px solid {_theme.BORDER}" width="173" height="108" />'
             )
 
+    # Reorganization-energy channels (REORG.1). This is the reported bug: the
+    # card came back without the numbers the calculation exists to produce.
+    # Keyed on the calc type AND the payload, so a reorg result saved before λ
+    # persistence gets an explanation instead of a silently incomplete card.
+    _reorg_html = ""
+    if ct == "reorganization_energy":
+        _channels = data.get("reorg_channels")
+        if _channels:
+            _attach_relaxation_from_saved(_channels, data)
+            _reorg_html = reorg_channels_html(_channels)
+        else:
+            _reorg_html = reorg_missing_data_notice()
+
     return (
         f'<div style="background:#f0fff0;border-left:4px solid #4CAF50;'
         f'padding:10px 14px;border-radius:4px;margin:6px 0;overflow:hidden">'
@@ -491,5 +728,5 @@ def format_past_result(data: dict[str, Any], result_dir: Optional[Path] = None)
         f'<b>{data["formula"]} &mdash; {data["method"]}/{data["basis"]}</b>'
         f'&ensp;<small style="color:#777">{ts}</small>'
         f'<table style="margin-top:8px;font-size:14px;border-collapse:collapse">'
-        f"{_rows}{_extra}</table></div>"
+        f"{_rows}{_extra}</table>{_reorg_html}</div>"
     )