chemparseplot 1.9.9__tar.gz → 1.9.11__tar.gz

{chemparseplot-1.9.9 → chemparseplot-1.9.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chemparseplot
-Version: 1.9.9
+Version: 1.9.11
 Summary: Parsers and plotting tools for computational chemistry
 Project-URL: Documentation, https://chemparseplot.rgoswami.me
 Project-URL: Issues, https://github.com/HaoZeke/chemparseplot/issues

{chemparseplot-1.9.9 → chemparseplot-1.9.11}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.9.9'
-__version_tuple__ = version_tuple = (1, 9, 9)
+__version__ = version = '1.9.11'
+__version_tuple__ = version_tuple = (1, 9, 11)
 
 __commit_id__ = commit_id = None

{chemparseplot-1.9.9 → chemparseplot-1.9.11}/chemparseplot/plot/neb.py

@@ -988,6 +988,36 @@ def surface_fit_indices(n: int, max_points: int) -> np.ndarray:
     return idx
 
 
+@dataclass(frozen=True, slots=True)
+class SurfaceFitConfig:
+    """Declarative surface-fit knobs (TOML-friendly mapping).
+
+    Prefer this over growing positional/flag lists. Key names match
+    rgpycrumbs eOn plot TOML (``[shared]`` / ``[min]`` / ``[neb]``)::
+
+        auto_thin = false
+        max_surface_points = 64
+
+    Defaults keep historical behaviour (no thinning).
+
+    ```{versionadded} 1.9.10
+    ```
+    """
+
+    auto_thin: bool = False
+    max_surface_points: int = 64
+
+    @classmethod
+    def from_mapping(cls, data: Mapping[str, Any] | None) -> SurfaceFitConfig:
+        """Build from a TOML table or plain dict (unknown keys ignored)."""
+        if not data:
+            return cls()
+        return cls(
+            auto_thin=bool(data.get("auto_thin", False)),
+            max_surface_points=int(data.get("max_surface_points", 64)),
+        )
+
+
 def plot_landscape_surface(
     ax,
     rmsd_r,
@@ -1009,6 +1039,7 @@ def plot_landscape_surface(
     basis=None,
     auto_thin: bool = False,  # noqa: FBT001, FBT002
     max_surface_points: int = 64,
+    surface_fit: SurfaceFitConfig | Mapping[str, Any] | None = None,
 ) -> Any:
     """Plot the 2D landscape surface using reaction valley projection.
 
@@ -1035,6 +1066,9 @@ def plot_landscape_surface(
         opt in (dense eOn min movies can otherwise yield non-finite grids).
     max_surface_points : int, default 64
         Cap on fit observations when ``auto_thin`` is True.
+    surface_fit : SurfaceFitConfig or mapping, optional
+        TOML-friendly config object. When given, overrides *auto_thin* and
+        *max_surface_points* (prefer this over ad-hoc kwargs).
 
     ```{versionadded} 0.1.0
     ```
@@ -1046,6 +1080,10 @@ def plot_landscape_surface(
     ```{versionadded} 1.9.9
     Added *auto_thin* and *max_surface_points*.
     ```
+
+    ```{versionadded} 1.9.10
+    Added *surface_fit* (:class:`SurfaceFitConfig` / mapping).
+    ```
     """
     from rgpycrumbs.surfaces import (
         NYSTROM_N_INDUCING_DEFAULT,
@@ -1054,6 +1092,14 @@ def plot_landscape_surface(
         nystrom_paths_needed,
     )
 
+    if surface_fit is not None:
+        if isinstance(surface_fit, SurfaceFitConfig):
+            fit_cfg = surface_fit
+        else:
+            fit_cfg = SurfaceFitConfig.from_mapping(surface_fit)
+        auto_thin = fit_cfg.auto_thin
+        max_surface_points = fit_cfg.max_surface_points
+
     rmsd_r = np.asarray(rmsd_r, dtype=float)
     rmsd_p = np.asarray(rmsd_p, dtype=float)
     z_data = np.asarray(z_data, dtype=float)

{chemparseplot-1.9.9 → chemparseplot-1.9.11}/chemparseplot/plot/optimization.py

@@ -352,6 +352,7 @@ def render_single_ended_landscape(
     perspective_tilt: float = 0.0,
     auto_thin: bool = False,
     max_surface_points: int = 64,
+    surface_fit: Any | None = None,
 ) -> None:
     """Full single-ended landscape pipeline shared by min/saddle CLIs.
 
@@ -368,6 +369,10 @@ def render_single_ended_landscape(
         (default False: opt-in subsampling of dense fit clouds).
     max_surface_points
         Cap on fit observations when ``auto_thin`` is True.
+    surface_fit
+        Optional :class:`~chemparseplot.plot.neb.SurfaceFitConfig` or mapping
+        (TOML table keys). When set, overrides *auto_thin* /
+        *max_surface_points*.
 
     ```{versionadded} 1.8.1
     ```
@@ -375,6 +380,10 @@ def render_single_ended_landscape(
     ```{versionadded} 1.9.9
     Added *auto_thin* and *max_surface_points*.
     ```
+
+    ```{versionadded} 1.9.10
+    Added *surface_fit*.
+    ```
     """
     from matplotlib import ticker
 
@@ -434,6 +443,7 @@ def render_single_ended_landscape(
         z_label=z_label,
         auto_thin=auto_thin,
         max_surface_points=max_surface_points,
+        surface_fit=surface_fit,
     )
     if cb is not None:
         cb.ax.yaxis.set_major_formatter(ticker.FormatStrFormatter("%.3f"))

{chemparseplot-1.9.9 → chemparseplot-1.9.11}/tests/plot/test_surface_auto_thin.py

@@ -112,3 +112,76 @@ class TestPlotLandscapeSurfaceAutoThin:
         assert seen["n"] <= 64
         assert seen["n"] < n
         plt.close(fig)
+
+
+class TestSurfaceFitConfig:
+    def test_from_mapping_defaults(self):
+        from chemparseplot.plot.neb import SurfaceFitConfig
+
+        cfg = SurfaceFitConfig.from_mapping(None)
+        assert cfg.auto_thin is False
+        assert cfg.max_surface_points == 64
+
+    def test_from_mapping_overrides(self):
+        from chemparseplot.plot.neb import SurfaceFitConfig
+
+        cfg = SurfaceFitConfig.from_mapping(
+            {"auto_thin": True, "max_surface_points": 48, "noise": "ignored"}
+        )
+        assert cfg.auto_thin is True
+        assert cfg.max_surface_points == 48
+
+    def test_surface_fit_kwarg_overrides_scalars(self):
+        import sys
+        import types
+
+        import matplotlib.pyplot as plt
+        import numpy as np
+
+        from chemparseplot.plot import neb as neb_mod
+        from chemparseplot.plot.neb import SurfaceFitConfig
+
+        seen: dict = {}
+
+        class DummyModel:
+            def __init__(self, **kwargs):
+                x = kwargs.get("x", kwargs.get("x_obs"))
+                seen["n"] = len(x)
+                self.ls = 0.5
+                self.noise = 1e-2
+
+            def __call__(self, pts):
+                return np.zeros(len(pts))
+
+            def predict_var(self, pts):
+                return np.ones(len(pts)) * 0.01
+
+        fake = types.ModuleType("rgpycrumbs.surfaces")
+        fake.NYSTROM_N_INDUCING_DEFAULT = 300
+        fake.NYSTROM_THRESHOLD = 1000
+        fake.get_surface_model = lambda method: DummyModel
+        fake.nystrom_paths_needed = lambda *a, **k: 1
+        sys.modules["rgpycrumbs.surfaces"] = fake
+        sys.modules.setdefault("rgpycrumbs", types.ModuleType("rgpycrumbs"))
+
+        n = 100
+        r = np.linspace(0.0, 1.0, n)
+        p = np.linspace(1.0, 0.0, n)
+        z = np.linspace(0.0, 0.2, n)
+        fig, ax = plt.subplots()
+        neb_mod.plot_landscape_surface(
+            ax,
+            r,
+            p,
+            np.zeros(n),
+            np.zeros(n),
+            z,
+            method="rbf",
+            project_path=False,
+            show_pts=False,
+            auto_thin=False,
+            max_surface_points=64,
+            surface_fit=SurfaceFitConfig(auto_thin=True, max_surface_points=20),
+        )
+        assert seen["n"] <= 20
+        plt.close(fig)