gratinglab 0.1.12__tar.gz → 0.2.0__tar.gz

{gratinglab-0.1.12/src/gratinglab.egg-info → gratinglab-0.2.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: gratinglab
-Version: 0.1.12
+Version: 0.2.0
 Summary: Open platform for diffraction grating groove metrology and efficiency analysis
-Author: Jake McCoy
+Author: Jake McCoy, Aditi Gangadharan
 License: BSD-3-Clause
 Project-URL: Homepage, https://github.com/jamccoy/gratinglab
 Project-URL: Changelog, https://github.com/jamccoy/gratinglab/blob/master/CHANGELOG.md
@@ -23,6 +23,7 @@ Requires-Dist: numpy>=1.26
 Requires-Dist: scipy>=1.11
 Requires-Dist: pydantic>=2.6
 Requires-Dist: endstation>=0.2.2
+Requires-Dist: threadpoolctl>=3.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-qt>=4.5; extra == "dev"
@@ -271,7 +272,9 @@ gratinglab-metrology-gui       # straight to AFM import, blaze angles, boundary
 ```
 
 There are two windows, and `gratinglab-app` is the front door that asks which one
-you want. Both halves are this one package — the metrology measures a groove and the
+you want. Neither is a dead end: each carries a **Go** menu that switches to the other
+and returns to the chooser (`Ctrl+Shift+M`), and switching reuses a window that is
+already open rather than starting a second empty copy of it. Both halves are this one package — the metrology measures a groove and the
 solvers compute an efficiency from the result — but the desktop layer used to ship
 them as two commands and two application bundles, the AFM one still named after the
 repository it was merged from, which made the half in regular use the half that was

{gratinglab-0.1.12 → gratinglab-0.2.0}/README.md

@@ -227,7 +227,9 @@ gratinglab-metrology-gui       # straight to AFM import, blaze angles, boundary
 ```
 
 There are two windows, and `gratinglab-app` is the front door that asks which one
-you want. Both halves are this one package — the metrology measures a groove and the
+you want. Neither is a dead end: each carries a **Go** menu that switches to the other
+and returns to the chooser (`Ctrl+Shift+M`), and switching reuses a window that is
+already open rather than starting a second empty copy of it. Both halves are this one package — the metrology measures a groove and the
 solvers compute an efficiency from the result — but the desktop layer used to ship
 them as two commands and two application bundles, the AFM one still named after the
 repository it was merged from, which made the half in regular use the half that was

{gratinglab-0.1.12 → gratinglab-0.2.0}/pyproject.toml

@@ -13,7 +13,7 @@ description = "Open platform for diffraction grating groove metrology and effici
 readme = "README.md"
 requires-python = ">=3.11"
 license = { text = "BSD-3-Clause" }
-authors = [{ name = "Jake McCoy" }]
+authors = [{ name = "Jake McCoy" }, { name = "Aditi Gangadharan" }]
 # Wavelength-neutral on purpose. The off-plane work this package grew out of is
 # soft x-ray, and that band is still named, but nothing in the solvers or the
 # metrology assumes one: the grating equation carries no band, and the
@@ -52,6 +52,13 @@ dependencies = [
     # so this line adds no transitive weight -- the Qt and matplotlib parts sit
     # behind its own extras, which our `gui` extra asks for by name.
     "endstation>=0.2.2",
+    # The rigorous solvers cap BLAS threads for the length of a solve
+    # (solvers/_execution.py): OpenBLAS's thread-per-core default made RCWA
+    # up to 135x slower on a busy machine, measured in benchmarks/
+    # solver_speed.py. NumPy and SciPy each load their own OpenBLAS, and
+    # this is the one maintained way to reach both. Pure Python, BSD-3, no
+    # dependencies of its own.
+    "threadpoolctl>=3.1",
 ]
 
 [project.optional-dependencies]

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/__init__.py

@@ -22,7 +22,7 @@ from .measured import MeasuredEfficiency, MeasurementProvenance
 from .resolution import ResolvingPower, resolving_power
 from .result import EfficiencyScan, OrderEfficiency, Provenance
 
-__version__ = "0.1.12"
+__version__ = "0.2.0"
 
 __all__ = [
     "Illumination",

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/checks.py

@@ -238,6 +238,9 @@ def check_energy_balance(
 
     Notes
     -----
+    Transmitted orders, when the scan records them, are added to the sum: the
+    power a lossless substrate carries away is accounted for, not lost.
+
     When the scan records an absorbed fraction (``scan.absorption``, from a
     solver that computes one independently), the conserved quantity is the
     sum plus the absorption, and that is what is checked. ``R + A = 1`` is a
@@ -253,6 +256,8 @@ def check_energy_balance(
     reached 3.6.
     """
     total = np.asarray(scan.total, dtype=np.float64)
+    if scan.transmission is not None:
+        total = total + scan.transmission.total
     if scan.absorption is not None:
         total = total + scan.absorption
     return EnergyReport(

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/docs.py

@@ -44,8 +44,10 @@ __all__ = [
 #: name for anything not listed here, so a new solver still gets a menu entry
 #: before anyone remembers to add a nicer title.
 _TITLES = {
+    "cmethod": "C-method (Chandezon)",
     "scalar": "Scalar (Kirchhoff)",
     "integral": "Integral (boundary integral equation)",
+    "rcwa": "RCWA (Fourier modal method)",
 }
 
 #: Non-solver reference pages: (key, title, filename relative to docs/).
@@ -105,6 +107,17 @@ def display_title(name: str) -> str:
     return _TITLES.get(name, name)
 
 
+def short_title(name: str) -> str:
+    """A solver's tab label: its display title without the bracketed gloss.
+
+    ``"Integral (boundary integral equation)"`` becomes ``"Integral"``. The
+    full title was the tab label until 2026-10-27, and with four tabs plus the
+    geometry dock it already overflowed the bar, so every new solver made it
+    worse. The full title stays in the Help menu and the tab's tooltip.
+    """
+    return display_title(name).split(" (", 1)[0]
+
+
 def find_theory_root(start: Path | None = None) -> Path | None:
     """Search upward from ``start`` for a ``docs/theory`` directory.
 

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/efficiency_plot.py

@@ -50,6 +50,14 @@ def draw_efficiency(
         scan.wavelengths, scan.total,
         color=theme.ink, ls="--", lw=1.0, alpha=0.7, label="Σ",
     )
+    transmitted = (
+        scan.transmission.total if scan.transmission is not None else 0.0
+    )
+    if scan.transmission is not None:
+        axes.plot(
+            scan.wavelengths, scan.transmission.total,
+            color=theme.ink, lw=1.0, ls=":", alpha=0.9, label="T",
+        )
     if scan.absorption is not None:
         # Under a finite-conductivity solve Σ alone is the reflected fraction
         # and sits below the unity line by exactly the absorbed one. Drawing
@@ -61,8 +69,9 @@ def draw_efficiency(
             color=theme.warn, lw=1.0, ls="-.", alpha=0.9, label="A",
         )
         axes.plot(
-            scan.wavelengths, scan.total + scan.absorption,
-            color=theme.ink, lw=1.0, ls="-", alpha=0.5, label="Σ + A",
+            scan.wavelengths, scan.total + transmitted + scan.absorption,
+            color=theme.ink, lw=1.0, ls="-", alpha=0.5,
+            label="Σ + T + A" if scan.transmission is not None else "Σ + A",
         )
     axes.axhline(1.0, color=theme.bad, lw=0.8, ls=":", alpha=0.8)
     axes.set_xlabel("wavelength (nm)")

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/launcher.py

@@ -101,7 +101,7 @@ def _require_qt():
 def main(argv=None) -> int:
     """Console-script entry point for ``gratinglab-app``."""
     QApplication = _require_qt()
-    from .qt.launcher import LauncherWindow
+    from .qt.launcher import show_chooser
 
     app = QApplication.instance() or QApplication(list(argv or sys.argv))
     # Fusion for the same reason the metrology window asks for it: the native
@@ -111,10 +111,9 @@ def main(argv=None) -> int:
 
     install(app)
 
-    window = LauncherWindow()
-    window.show()
-    window.raise_()
-    window.activateWindow()
+    # show_chooser, not LauncherWindow(), so that "Main Menu" in either
+    # window brings this same chooser back instead of a second copy.
+    show_chooser()
     return app.exec()
 
 

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/provenance.py

@@ -147,6 +147,16 @@ def provenance_lines(
         lines.append(Line("normalization: ", "dim"))
         lines.append(Line(f"{normalization} ({detail})\n", "dim"))
 
+    if scan.transmission is not None:
+        lines.append(Line("transmission: ", "dim"))
+        lines.append(
+            Line(
+                f"T ∈ [{scan.transmission.total.min():.4f}, "
+                f"{scan.transmission.total.max():.4f}]\n",
+                "dim",
+            )
+        )
+
     if scan.absorption is not None:
         # A physical result, not a problem: `dim`, never an alarm tag. It also
         # explains the deficit in Σ below, which would otherwise read as a
@@ -163,7 +173,9 @@ def provenance_lines(
     # `check_energy_balance` folds absorption into the total when a scan
     # carries one, so the conserved quantity is R + A there. Naming it Σ
     # anyway would collide with the Σ curve on the plot, which is R alone.
-    conserved = "Σ + A" if scan.absorption is not None else "Σ"
+    conserved = "Σ" + (" + T" if scan.transmission is not None else "") + (
+        " + A" if scan.absorption is not None else ""
+    )
     lines.append(Line("energy balance: ", "dim"))
     lines.append(
         Line(

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/qt/launcher.py

@@ -11,6 +11,7 @@ from functools import partial
 from importlib import import_module
 
 from PySide6.QtCore import Qt
+from PySide6.QtGui import QKeySequence
 from PySide6.QtWidgets import (
     QFrame,
     QHBoxLayout,
@@ -23,7 +24,19 @@ from PySide6.QtWidgets import (
 
 from ..launcher import MODES
 
-__all__ = ["LauncherWindow", "open_window"]
+__all__ = [
+    "LauncherWindow",
+    "SWITCH_MENU_TITLE",
+    "install_switch_menu",
+    "open_window",
+    "show_chooser",
+    "window_for",
+]
+
+#: Title of the menu each window gets, through which the other mode and the
+#: chooser are reachable. Not "Window": macOS has conventions for a menu of
+#: that name and these are modes, not windows of one document.
+SWITCH_MENU_TITLE = "&Go"
 
 #: Windows opened from the chooser, kept alive deliberately.
 #:
@@ -34,17 +47,86 @@ __all__ = ["LauncherWindow", "open_window"]
 _OPEN_WINDOWS: list[QWidget] = []
 
 
+#: The chooser, kept so that "Main Menu" shows the same one rather than a
+#: second copy. Closing a window does not destroy it while a reference is
+#: held, so this one can be shown again after it closed itself.
+_CHOOSER: list = []
+
+
+def window_for(chosen):
+    """The window already open for a mode, or None.
+
+    Opening a second window for a mode would be worse than useless: the
+    metrology window holds a loaded scan and its settings, so a "switch" that
+    quietly produced an empty second copy would look like losing the work.
+    """
+    for window in _OPEN_WINDOWS:
+        if getattr(window, "_gratinglab_mode", None) == chosen.key:
+            return window
+    return None
+
+
+def _raise(window):
+    """Show a window that may be open behind something, or closed."""
+    window.show()
+    window.raise_()
+    window.activateWindow()
+    return window
+
+
+def install_switch_menu(window, current):
+    """Give a window a menu leading to the other mode and to the chooser.
+
+    Added from here rather than by each window, so that neither window needs
+    to know the other exists and a third mode is still one entry in MODES.
+
+    The menu and its actions are held on the window. `gui/qt/main_window.py`
+    records why: under PySide6 a QMenu reached back through
+    ``menuBar().actions()[i].menu()`` is not reliably usable, so whatever
+    builds a menu must keep it.
+    """
+    menu = window.menuBar().addMenu(SWITCH_MENU_TITLE)
+    window._gratinglab_switch_menu = menu
+
+    actions = []
+    for other in MODES:
+        if other.key == current.key:
+            continue
+        action = menu.addAction(other.title)
+        action.triggered.connect(partial(open_window, other))
+        actions.append(action)
+
+    menu.addSeparator()
+    back = menu.addAction("Main Menu")
+    back.setShortcut(QKeySequence("Ctrl+Shift+M"))
+    back.triggered.connect(show_chooser)
+    actions.append(back)
+
+    window._gratinglab_switch_actions = actions
+    return menu
+
+
 def open_window(chosen):
-    """Import the window a mode names, show it, and keep it alive."""
+    """Show the window a mode names, reusing it if it is already open."""
+    existing = window_for(chosen)
+    if existing is not None:
+        return _raise(existing)
+
     module_name, _, attribute = chosen.window.partition(":")
     window_class = getattr(import_module(module_name), attribute)
 
     window = window_class()
+    window._gratinglab_mode = chosen.key
+    install_switch_menu(window, chosen)
     _OPEN_WINDOWS.append(window)
-    window.show()
-    window.raise_()
-    window.activateWindow()
-    return window
+    return _raise(window)
+
+
+def show_chooser():
+    """Bring the chooser back, the same one if it has been up before."""
+    if not _CHOOSER:
+        _CHOOSER.append(LauncherWindow())
+    return _raise(_CHOOSER[0])
 
 
 class LauncherWindow(QWidget):
@@ -80,7 +162,9 @@ class LauncherWindow(QWidget):
         layout.addStretch(1)
 
         hint = QLabel(
-            "Each window is also a command of its own: "
+            "Either window's <b>Go</b> menu switches to the other and comes "
+            "back here, so this is not a one-way door. Each is also a command "
+            "of its own: "
             + ", ".join(f"<code>{m.script}</code>" for m in MODES)
             + "."
         )

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/qt/main_window.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 import threading
 
 from PySide6.QtCore import Qt, QThread, QTimer, Signal
-from PySide6.QtGui import QActionGroup, QKeySequence
+from PySide6.QtGui import QKeySequence
 from PySide6.QtWidgets import (
     QDockWidget,
     QMainWindow,
@@ -38,7 +38,6 @@ from PySide6.QtWidgets import (
 
 from .. import provenance
 from ..state import FormErrors, build, validate
-from ..theme import SYSTEM, THEMES
 from . import theming
 from .geometry_panel import GeometryPanel
 from .geometry_tab import GeometryTab
@@ -189,7 +188,7 @@ class MainWindow(QMainWindow):
         self.resizeDocks([dock], [300], Qt.Orientation.Horizontal)
 
     def _build_tabs(self) -> QWidget:
-        from ..docs import display_title
+        from ..docs import display_title, short_title
         from ...solvers import available_solvers
 
         self.tabs: dict[str, QWidget] = {}
@@ -220,7 +219,8 @@ class MainWindow(QMainWindow):
                 # has nothing to sweep and should not carry the button.
                 converge.connect(lambda _checked=False, n=name: self.solve(n, sweep=True))
             self.tabs[name] = tab
-            self._tab_widget.addTab(tab, display_title(name))
+            index = self._tab_widget.addTab(tab, short_title(name))
+            self._tab_widget.setTabToolTip(index, display_title(name))
 
         # Setup is leftmost so it is easy to find, but a solver tab -- not
         # the explanatory stub -- is what should be showing, and solving,
@@ -284,19 +284,11 @@ class MainWindow(QMainWindow):
         self._view_menu.addSeparator()
 
         # One exclusive group: System follows the OS, the rest are fixed.
-        self._theme_menu = self._view_menu.addMenu("&Theme")
-        self._theme_actions = QActionGroup(self)
-        self._theme_actions.setExclusive(True)
-        choices = [(SYSTEM, "System")] + [(k, t.label) for k, t in THEMES.items()]
-        for key, label in choices:
-            action = self._theme_menu.addAction(label)
-            action.setCheckable(True)
-            action.setData(key)
-            action.setChecked(key == self._themes.choice)
-            action.triggered.connect(lambda _checked=False, k=key: self.set_theme(k))
-            self._theme_actions.addAction(action)
-            if key == SYSTEM:
-                self._theme_menu.addSeparator()
+        # Shared with the AFM window, so both offer it and both stay checked
+        # in step whichever one the choice was made in.
+        self._theme_menu = theming.ThemeMenu(self)
+        self._view_menu.addMenu(self._theme_menu)
+        self._theme_actions = self._theme_menu._group
 
         menu = self._help_menu = self._menu_bar.addMenu("&Help")
         menu.addAction("About GratingLab", self.show_about)
@@ -320,8 +312,6 @@ class MainWindow(QMainWindow):
     def set_theme(self, choice: str) -> None:
         """Switch theme by key, or ``"system"``; the menu calls this."""
         self._themes.set_choice(choice)
-        for action in self._theme_actions.actions():
-            action.setChecked(action.data() == choice)
 
     def _start_worker(self) -> None:
         self._thread = QThread(self)

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/gui/qt/theming.py

@@ -22,14 +22,16 @@ import os
 from collections.abc import Callable
 
 from PySide6.QtCore import QObject, QSettings, Qt, Signal
-from PySide6.QtGui import QColor, QGuiApplication, QIcon, QPalette, QPixmap
-from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import (QAction, QActionGroup, QColor, QGuiApplication,
+                           QIcon, QPalette, QPixmap)
+from PySide6.QtWidgets import QApplication, QMenu
 
 from ..theme import DARK, LIGHT, SYSTEM, THEMES, Theme, rc_params
 
 __all__ = [
     "QIcon",
     "SETTINGS_ENV",
+    "ThemeMenu",
     "ThemeManager",
     "current",
     "install",
@@ -187,6 +189,50 @@ def subscribe(callback: Callable[[Theme], None]) -> None:
         found.changed.connect(callback)
 
 
+class ThemeMenu(QMenu):
+    """The View > Theme submenu, one per window, all kept in step.
+
+    Every window that has a menu bar carries one, built here so that none can
+    be left without it: the AFM window had no theme choice at all while the
+    efficiency window did. Choosing in one window re-checks the others,
+    because each menu follows the manager's ``changed`` signal rather than
+    its own clicks.
+    """
+
+    def __init__(self, parent=None) -> None:
+        super().__init__("&Theme", parent)
+        self._group = QActionGroup(self)
+        self._group.setExclusive(True)
+        choices = [(SYSTEM, "System")] + [(k, t.label) for k, t in THEMES.items()]
+        for key, label in choices:
+            action = self.addAction(label)
+            action.setCheckable(True)
+            action.setData(key)
+            action.triggered.connect(self._chosen)
+            self._group.addAction(action)
+            if key == SYSTEM:
+                self.addSeparator()
+        found = manager()
+        if found is not None:
+            found.changed.connect(self._sync)
+        self._sync()
+
+    def actions_by_key(self) -> dict[str, QAction]:
+        return {a.data(): a for a in self._group.actions()}
+
+    def _chosen(self) -> None:
+        action = self.sender()
+        found = manager()
+        if found is not None and isinstance(action, QAction):
+            found.set_choice(action.data())
+
+    def _sync(self, _theme=None) -> None:
+        found = manager()
+        choice = found.choice if found is not None else SYSTEM
+        for key, action in self.actions_by_key().items():
+            action.setChecked(key == choice)
+
+
 def swatch(color: str, size: int = 12) -> QIcon:
     """A square of ``color``, for a list entry that names a plotted line."""
     pixmap = QPixmap(size, size)

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/io/boundary.py

@@ -63,7 +63,8 @@ class BoundaryFile:
     """A groove profile read back from a gratinglab ``.json``."""
 
     period_nm: float
-    #: Fractions of one period, as :class:`~gratinglab.profiles.FromProfileData` takes them.
+    #: Fractions of one period along ``+d-hat``, as ``x_norm`` and a ``.ggp``
+    #: hold them; :meth:`profile` reflects them into the profile parameter.
     t: tuple[float, ...]
     y: tuple[float, ...]
     #: Grooves averaged into this profile, carried onto the problem.
@@ -77,7 +78,9 @@ class BoundaryFile:
         """The shape, as the solvers take it."""
         from ..profiles import FromProfileData
 
-        return FromProfileData(t=self.t, y=self.y, blaze_angle=self.blaze_angle)
+        return FromProfileData.along_dispersion(
+            self.t, self.y, blaze_angle=self.blaze_angle
+        )
 
     def to_problem(self, *, coating=None, substrate=None, roughness=0.0):
         """This groove as an efficiency problem, with the period it was measured at.

{gratinglab-0.1.12 → gratinglab-0.2.0}/src/gratinglab/io/ggp.py

@@ -2,8 +2,13 @@
 
 A ``.ggp`` holds a groove profile normalised to the period: ``x`` runs 0 to 1
 across exactly one period and ``y`` is height as a fraction of that period.
-This is the same convention :mod:`gratinglab.profiles` uses, so no rescaling is
-needed.
+The scale is the one :mod:`gratinglab.profiles` uses, so no rescaling is
+needed. The direction is not: ``x`` advances along the dispersion direction
+and a profile's ``t`` against it (``docs/conventions.md``, "Direction of the
+profile parameter"), so :func:`to_profile` and :func:`write_ggp` reflect the
+points through :meth:`~gratinglab.profiles.FromProfileData.along_dispersion`
+and its inverse. The PCGrate corpus is what fixes the file's direction: the
+TASTE run matches only with ``x`` along ``+d-hat``.
 
 Canonical form::
 
@@ -196,9 +201,10 @@ def to_profile(ggp: GgpFile) -> FromProfileData:
     """Convert to a :class:`~gratinglab.profiles.FromProfileData`.
 
     Heights are referenced to the profile minimum so the valley sits at zero,
-    matching every analytic profile in :mod:`gratinglab.profiles`.
+    matching every analytic profile in :mod:`gratinglab.profiles`. The file's
+    ``x`` runs along ``+d-hat``, so the points are reflected into ``t``.
     """
-    return FromProfileData(t=tuple(ggp.t), y=tuple(ggp.y - ggp.y.min()))
+    return FromProfileData.along_dispersion(ggp.t, ggp.y - ggp.y.min())
 
 
 def read_profile(path: str | Path) -> FromProfileData:
@@ -213,14 +219,26 @@ def write_ggp(
     t: ArrayLike | None = None,
     y: ArrayLike | None = None,
     fmt: str = "%f",
+    header: bool = True,
 ) -> Path:
     """Write a profile in the canonical, PCGrate-loadable form.
 
-    Pass either a ``profile`` or explicit ``t``/``y`` arrays.
-
-    Values are written to six decimals, single-space separated and newline
-    terminated. The format is
-    pinned by ``tests/test_ggp.py``; PCGrate rejects variations on it.
+    Pass either a ``profile`` or explicit ``t``/``y`` arrays. A profile is
+    reflected onto the file's ``+d-hat`` axis, the inverse of
+    :func:`to_profile`. Explicit arrays are written as given, so they are
+    file coordinates already, as the metrology pipeline's ``x_norm`` is.
+
+    Values are written to six decimals, single-space separated, one point per
+    line, with no line break after the last point. PCGrate rejects a file
+    that ends in one, as ``np.savetxt`` output does. The format is pinned by
+    ``tests/test_ggp.py``; PCGrate rejects variations on it.
+
+    ``header=False`` leaves out the two :data:`GGP_HEADER` lines and writes
+    the points alone, as ``np.savetxt`` with no ``header`` does. It exists to
+    test the claim in the module docstring that PCGrate needs the header:
+    that claim comes from the files found on disk, not from PCGrate's
+    documentation, and Aditi's script writes headerless files (2026-10-27).
+    Reading such a file back reports ``header_variant == "none"``.
     """
     if (profile is None) == (t is None):
         raise ValueError("pass either a profile or both t and y, not both or neither")
@@ -231,8 +249,7 @@ def write_ggp(
                 "cannot write an undercut profile as .ggp: PCGrate's polygonal "
                 "border expects a boundary that advances monotonically in x"
             )
-        t_values = np.asarray(profile.t, dtype=np.float64)
-        y_values = np.asarray(profile.y, dtype=np.float64)
+        t_values, y_values = profile.dispersion_axis()
     else:
         t_values = np.asarray(t, dtype=np.float64)
         y_values = np.asarray(y, dtype=np.float64)
@@ -243,8 +260,11 @@ def write_ggp(
 
     path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
+    points = (f"{fmt % x_value} {fmt % height}"
+              for x_value, height in zip(t_values, y_values))
     with path.open("w", encoding="utf-8") as handle:
-        handle.write(GGP_HEADER + "\n")
-        for x_value, height in zip(t_values, y_values):
-            handle.write(f"{fmt % x_value} {fmt % height}\n")
+        # No line break after the last point: PCGrate reads a trailing one as
+        # an extra, empty point and rejects the file (found by Aditi,
+        # 2026-10-27).
+        handle.write("\n".join([GGP_HEADER, *points] if header else points))
     return path