fix(pair-tab): validate uniform distance grid to avoid silently wrong potentials

deepmd/utils/pair_tab.py

@@ -57,17 +57,39 @@ def reinit(self, filename: str, rcut: float | None = None) -> None:
         if filename is None:
             self.tab_info, self.tab_data = None, None
             return
-        self.vdata = np.loadtxt(filename, dtype=self.data_type)
-        self.rmin = self.vdata[0][0]
-        self.rmax = self.vdata[-1][0]
-        self.hh = self.vdata[1][0] - self.vdata[0][0]
-        ncol = self.vdata.shape[1] - 1
+        vdata = np.loadtxt(filename, dtype=self.data_type)
+        rmin = vdata[0][0]
+        rmax = vdata[-1][0]
+        hh = vdata[1][0] - vdata[0][0]
+        dx = np.diff(vdata[:, 0])
+        if not np.all(dx > 0):
+            raise ValueError(
+                f"The distance grid in the pairwise table {filename} is not "
+                "strictly increasing. The tabulated potential must be provided "
+                "on a uniform grid with distances sorted in ascending order and "
+                "without duplicated rows. Please regrid the table."
+            )
+        if not np.allclose(dx, hh, rtol=1e-5, atol=1e-8):
+            raise ValueError(
+                f"The distance grid in the pairwise table {filename} is not "
+                "evenly spaced. The tabulated potential must be provided on a "
+                "uniform grid, but the stride inferred from the first two rows "
+                f"({hh}) does not match all distance intervals. Please "
+                "regrid the table to use a constant distance step."
+            )
+        ncol = vdata.shape[1] - 1
         n0 = (-1 + np.sqrt(1 + 8 * ncol)) * 0.5
-        self.ntypes = int(n0 + 0.1)
-        assert self.ntypes * (self.ntypes + 1) // 2 == ncol, (
-            f"number of volumes provided in {filename} does not match guessed number of types {self.ntypes}"
+        ntypes = int(n0 + 0.1)
+        assert ntypes * (ntypes + 1) // 2 == ncol, (
+            f"number of volumes provided in {filename} does not match guessed number of types {ntypes}"
         )
 
+        self.vdata = vdata
+        self.rmin = rmin
+        self.rmax = rmax
+        self.hh = hh
+        self.ntypes = ntypes
+
         # check table data against rcut and update tab_file if needed, table upper boundary is used as rcut if not provided.
         self.rcut = rcut if rcut is not None else self.rmax
         self._check_table_upper_boundary()

source/tests/common/dpmodel/test_pairtab_preprocess.py

@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
+import copy
 import unittest
 from unittest.mock import (
     patch,
@@ -275,5 +276,96 @@ def test_preprocess(self) -> None:
         )
 
 
+class TestPairTabGridSpacing(unittest.TestCase):
+    @patch("numpy.loadtxt")
+    def test_non_uniform_grid(self, mock_loadtxt) -> None:
+        mock_loadtxt.return_value = np.array(
+            [
+                [0.00, 1.0],
+                [0.01, 0.8],
+                [0.02, 0.6],
+                [0.09, 0.3],
+                [0.16, 0.0],
+            ]
+        )
+        with self.assertRaisesRegex(ValueError, "evenly spaced"):
+            PairTab(filename="dummy_path", rcut=0.16)
+
+    @patch("numpy.loadtxt")
+    def test_duplicate_distances(self, mock_loadtxt) -> None:
+        mock_loadtxt.return_value = np.array(
+            [
+                [0.01, 1.0],
+                [0.01, 0.8],
+                [0.01, 0.6],
+                [0.01, 0.0],
+            ]
+        )
+        with self.assertRaisesRegex(ValueError, "strictly increasing"):
+            PairTab(filename="dummy_path", rcut=0.04)
+
+    @patch("numpy.loadtxt")
+    def test_descending_grid(self, mock_loadtxt) -> None:
+        mock_loadtxt.return_value = np.array(
+            [
+                [0.04, 1.0],
+                [0.03, 0.8],
+                [0.02, 0.6],
+                [0.01, 0.0],
+            ]
+        )
+        with self.assertRaisesRegex(ValueError, "strictly increasing"):
+            PairTab(filename="dummy_path", rcut=0.04)
+
+    @patch("numpy.loadtxt")
+    def test_failed_reinit_keeps_state(self, mock_loadtxt) -> None:
+        uniform = np.array(
+            [
+                [0.00, 1.0],
+                [0.01, 0.8],
+                [0.02, 0.6],
+                [0.03, 0.3],
+                [0.04, 0.0],
+            ]
+        )
+        mock_loadtxt.return_value = uniform
+        tab = PairTab(filename="dummy_path", rcut=0.04)
+        expected = copy.deepcopy(tab.serialize())
+
+        mock_loadtxt.return_value = np.array(
+            [
+                [0.00, 1.0],
+                [0.01, 0.8],
+                [0.02, 0.6],
+                [0.09, 0.3],
+                [0.16, 0.0],
+            ]
+        )
+        with self.assertRaisesRegex(ValueError, "evenly spaced"):
+            tab.reinit(filename="dummy_path", rcut=0.16)
+
+        actual = tab.serialize()
+        for key in ("rmin", "rmax", "hh", "ntypes", "rcut", "nspline"):
+            self.assertEqual(actual[key], expected[key])
+        for key in ("vdata", "tab_info", "tab_data"):
+            np.testing.assert_array_equal(
+                actual["@variables"][key], expected["@variables"][key]
+            )
+
+    @patch("numpy.loadtxt")
+    def test_uniform_grid(self, mock_loadtxt) -> None:
+        mock_loadtxt.return_value = np.array(
+            [
+                [0.00, 1.0],
+                [0.01, 0.8],
+                [0.02, 0.6],
+                [0.03, 0.3],
+                [0.04, 0.0],
+            ]
+        )
+        tab = PairTab(filename="dummy_path", rcut=0.04)
+        np.testing.assert_allclose(tab.hh, 0.01)
+
+
 if __name__ == "__main__":
     unittest.main(warnings="ignore")