torchnep 1.0.0__py3-none-any.whl

torchnep/__init__.py

@@ -0,0 +1,22 @@
+# Copyright 2025 Yongchao Wu and the GPUMD development team
+# This file is part of GPUMD (Torchnep project).
+# GPUMD is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# GPUMD is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with GPUMD.  If not, see <http://www.gnu.org/licenses/>.
+
+__version__ = "1.0.0"
+
+from .predict import predict_dataset
+from .train import train_nep
+from .train_sharded import train_nep_sharded
+
+__all__ = [
+    "predict_dataset", "train_nep", "train_nep_sharded",
+]

torchnep/ase_calculator.py

@@ -0,0 +1,196 @@
+# Copyright 2025 Yongchao Wu and the GPUMD development team
+# This file is part of GPUMD (Torchnep project).
+# GPUMD is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# GPUMD is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with GPUMD.  If not, see <http://www.gnu.org/licenses/>.
+
+"""ASE interface for torchnep NEP4 models.
+
+This module provides :class:`NEP`, a standard ``ase.calculators.calculator.
+Calculator`` so that any ASE workflow (relaxation, MD, EOS, phonons, ...) can
+drive a trained NEP4 potential::
+
+    from ase.io import read
+    from torchnep.ase_calculator import NEP
+
+    atoms = read("POSCAR")
+    atoms.calc = NEP("nep.txt")
+    print(atoms.get_potential_energy())
+    print(atoms.get_forces())
+    print(atoms.get_stress())          # only for periodic cells
+
+``ase`` is an OPTIONAL dependency of torchnep — the core package (training and
+prediction) never imports it.  Importing *this* module requires ase to be
+installed; if it is not, a clear ImportError is raised here rather than deep
+inside ASE.  This is also why ``NEP`` is intentionally not re-exported from
+``torchnep/__init__.py``.
+"""
+
+import numpy as np
+
+try:
+    from ase.calculators.calculator import Calculator, all_changes
+    from ase.stress import full_3x3_to_voigt_6_stress
+except ModuleNotFoundError as exc:  # pragma: no cover - exercised only sans ase
+    raise ModuleNotFoundError(
+        "torchnep.ase_calculator requires the optional dependency 'ase'. "
+        "Install it with `pip install ase`."
+    ) from exc
+
+from .nep import NEPCalculator as _NEPCore
+
+
+def _resolve_dtype(dtype):
+    import torch
+    if isinstance(dtype, torch.dtype):
+        return dtype
+    return {"float64": torch.float64, "float32": torch.float32,
+            "double": torch.float64, "single": torch.float32}[str(dtype)]
+
+
+class NEP(Calculator):
+    """ASE calculator backed by a torchnep NEP4 model (``nep.txt``).
+
+    Parameters
+    ----------
+    model_file : str
+        Path to a GPUMD-format ``nep.txt`` (NEP4).
+    dtype : str or torch.dtype
+        Compute precision; ``"float64"`` (default) reproduces GPUMD to
+        round-off, ``"float32"`` is faster.
+    device : str or torch.device
+        Torch device, e.g. ``"cpu"`` (default) or ``"cuda"``.
+    **kwargs
+        Forwarded to ``ase.calculators.calculator.Calculator`` (e.g. ``label``).
+
+    Notes
+    -----
+    ``stress`` is only reported for fully periodic cells (a finite volume is
+    required); for molecules / clusters it is omitted.  Non-periodic systems
+    are handled by embedding the atoms in a vacuum box large enough that no
+    atom sees a periodic image within the model cutoff.
+    """
+
+    implemented_properties = ["energy", "energies", "free_energy",
+                              "forces", "stress"]
+
+    def __init__(self, model_file, dtype="float64", device="cpu",
+                 tiled="auto", block_size="auto", compile=False, **kwargs):
+        super().__init__(**kwargs)
+        self.nep = _NEPCore(model_file, dtype=_resolve_dtype(dtype),
+                            device=device)
+        # tiled: memory-bounded analytical inference for large cells.
+        #   True   -> always tile;  False -> never (autograd path);
+        #   "auto" -> tile once the system exceeds ``tiled_threshold`` atoms.
+        self.tiled = tiled
+        # block_size: "auto" sizes each tile from free memory; or an int override.
+        self.block_size = block_size
+        self.tiled_threshold = 50000
+        # compile: torch.compile the tiled kernels (CPU/CUDA only; one-time
+        # warm-up, then a dynamic graph that survives MD pair-count changes).
+        self.compile = bool(compile)
+
+    # -- helpers --------------------------------------------------------------
+    def _cell_for_neighbors(self, atoms):
+        """Return (cell_3x3, periodic) for the neighbor-list builder.
+
+        Fully periodic cells are passed through. Otherwise we wrap the atoms in
+        an orthorhombic vacuum box padded by ``2*rc`` so the builder's PBC
+        replicas never fall within the cutoff (emulating an isolated system).
+        """
+        if atoms.cell.rank == 3 and atoms.pbc.all():
+            return np.asarray(atoms.get_cell()[:], dtype=float), True
+        pos = atoms.get_positions()
+        rc = max(self.nep.rc_radial, self.nep.rc_angular)
+        span = pos.max(axis=0) - pos.min(axis=0) if len(pos) else np.zeros(3)
+        box = np.diag(span + 4.0 * rc + 1.0)
+        return box, False
+
+    # -- ASE entry point ------------------------------------------------------
+    def calculate(self, atoms=None, properties=("energy",),
+                  system_changes=all_changes):
+        super().calculate(atoms, properties, system_changes)
+        atoms = self.atoms  # set by super().calculate
+
+        cell, periodic = self._cell_for_neighbors(atoms)
+        species = atoms.get_chemical_symbols()
+        use_tiled = (self.tiled is True or
+                     (self.tiled == "auto" and len(species) >= self.tiled_threshold))
+        if use_tiled:
+            res = self.nep.compute_tiled(
+                species=species, positions=atoms.get_positions(),
+                cell=cell, block_size=self.block_size, compile=self.compile)
+        else:
+            res = self.nep.compute(
+                species=species, positions=atoms.get_positions(), cell=cell)
+        energies = res["energy"].detach().cpu().numpy()
+        forces = res["forces"].detach().cpu().numpy()
+
+        self.results["energies"] = energies
+        self.results["energy"] = float(energies.sum())
+        self.results["free_energy"] = self.results["energy"]
+        self.results["forces"] = forces
+
+        if periodic:
+            self.results["stress"] = self._stress_from_virial(
+                res["virial"], atoms.get_volume())
+
+    @staticmethod
+    def _stress_from_virial(virial, volume):
+        # Per-atom virial is (N, 9) row-major; W_ab = Σ rij_a * F_b.
+        # ASE stress σ = -W / V (Voigt order xx, yy, zz, yz, xz, xy).
+        w = virial.detach().cpu().numpy().sum(0).reshape(3, 3)
+        return full_3x3_to_voigt_6_stress(-w / volume)
+
+    def get_energy_components(self, atoms=None):
+        """Return the NEP / ZBL / total potential-energy split (eV).
+
+        Useful to inspect how much of the energy comes from the ZBL repulsive
+        baseline versus the neural-network NEP part::
+
+            {'nep': ..., 'zbl': ..., 'total': ...}
+
+        For a model trained without ZBL, ``'zbl'`` is 0 and ``'nep'`` equals
+        ``'total'``.  See :meth:`get_components` for forces and stress too.
+        """
+        return {k: v["energy"] for k, v in self.get_components(atoms).items()}
+
+    def get_components(self, atoms=None):
+        """Full NEP / ZBL / total breakdown of energy, forces, and stress.
+
+        Returns ``{'nep': {...}, 'zbl': {...}, 'total': {...}}`` where each
+        inner dict has ``'energy'`` (float, eV), ``'forces'`` ((N, 3) eV/Å) and,
+        for periodic cells, ``'stress'`` (6-vector Voigt, eV/ų).  The ``total``
+        block equals what ``get_potential_energy`` / ``get_forces`` /
+        ``get_stress`` return.
+        """
+        if atoms is None:
+            atoms = self.atoms
+        if atoms is None:
+            raise ValueError("No atoms supplied and none attached to the calculator.")
+
+        cell, periodic = self._cell_for_neighbors(atoms)
+        res = self.nep.compute(
+            species=atoms.get_chemical_symbols(),
+            positions=atoms.get_positions(),
+            cell=cell,
+            return_components=True,
+        )
+        vol = atoms.get_volume() if periodic else None
+        out = {}
+        for name, esuffix in (("nep", "_nep"), ("zbl", "_zbl"), ("total", "")):
+            e = res["energy" + esuffix].detach().cpu().numpy()
+            block = {"energy": float(e.sum()),
+                     "forces": res["forces" + esuffix].detach().cpu().numpy()}
+            if periodic:
+                block["stress"] = self._stress_from_virial(
+                    res["virial" + esuffix], vol)
+            out[name] = block
+        return out

torchnep/constants.py

@@ -0,0 +1,218 @@
+# Copyright 2025 Yongchao Wu and the GPUMD development team
+# This file is part of GPUMD (Torchnep project).
+# GPUMD is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# GPUMD is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with GPUMD.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Shared constants for NEP implementation."""
+
+PI = 3.141592653589793
+
+ELEMENTS = [
+    "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg",
+    "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr",
+    "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
+    "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd",
+    "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
+    "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf",
+    "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po",
+    "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu",
+    # Transuranics + transactinides (Z = 95–118).
+    "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr",
+    "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn",
+    "Nh", "Fl", "Mc", "Lv", "Ts", "Og",
+]
+
+# Maximum 3-body angular order supported by the implementation.
+MAX_L3B = 8
+
+# C3B coefficients for 3-body angular descriptors (from GPUMD).
+# Indexed [L*L - 1 + k] for L in 1..8, k in 0..2L; total = 3+5+7+9+11+13+15+17 = 80.
+C3B = [
+    0.238732414637843, 0.119366207318922, 0.119366207318922, 0.099471839432435,
+    0.596831036594608, 0.596831036594608, 0.149207759148652, 0.149207759148652,
+    0.139260575205408, 0.104445431404056, 0.104445431404056, 1.044454314040563,
+    1.044454314040563, 0.174075719006761, 0.174075719006761, 0.011190581936149,
+    0.223811638722978, 0.223811638722978, 0.111905819361489, 0.111905819361489,
+    1.566681471060845, 1.566681471060845, 0.195835183882606, 0.195835183882606,
+    0.013677377921960, 0.102580334414698, 0.102580334414698, 2.872249363611549,
+    2.872249363611549, 0.119677056817148, 0.119677056817148, 2.154187022708661,
+    2.154187022708661, 0.215418702270866, 0.215418702270866, 0.004041043476943,
+    0.169723826031592, 0.169723826031592, 0.106077391269745, 0.106077391269745,
+    0.424309565078979, 0.424309565078979, 0.127292869523694, 0.127292869523694,
+    2.800443129521260, 2.800443129521260, 0.233370260793438, 0.233370260793438,
+    0.004662742473395, 0.004079899664221, 0.004079899664221, 0.024479397985326,
+    0.024479397985326, 0.012239698992663, 0.012239698992663, 0.538546755677165,
+    0.538546755677165, 0.134636688919291, 0.134636688919291, 3.500553911901575,
+    3.500553911901575, 0.250039565135827, 0.250039565135827, 0.000082569397966,
+    0.005944996653579, 0.005944996653579, 0.104037441437634, 0.104037441437634,
+    0.762941237209318, 0.762941237209318, 0.114441185581398, 0.114441185581398,
+    5.950941650232678, 5.950941650232678, 0.141689086910302, 0.141689086910302,
+    4.250672607309055, 4.250672607309055, 0.265667037956816, 0.265667037956816,
+]
+assert len(C3B) == sum(2 * L + 1 for L in range(1, MAX_L3B + 1))  # 80
+
+# Z_COEFFICIENT[L][n1][n2]: polynomial coefficients such that the (L, n1)
+# angular basis element equals z_factor(z) * (x+iy)^n1, where
+#   z_factor(z) = sum_{n2} Z_COEFFICIENT[L][n1][n2] * z^n2
+# (only n2 with (L+n1) parity match the sum; others are stored as 0).
+# Matches NEP_CPU's Z_COEFFICIENT_1..8 tables; rows/cols padded to (L+1) * (L+1).
+Z_COEFFICIENT = [
+    None,  # L=0 unused
+    [[0.0, 1.0], [1.0, 0.0]],
+    [[-1.0, 0.0, 3.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0]],
+    [[0.0, -3.0, 0.0, 5.0], [-1.0, 0.0, 5.0, 0.0],
+     [0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]],
+    [[3.0, 0.0, -30.0, 0.0, 35.0], [0.0, -3.0, 0.0, 7.0, 0.0],
+     [-1.0, 0.0, 7.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0],
+     [1.0, 0.0, 0.0, 0.0, 0.0]],
+    [[0.0, 15.0, 0.0, -70.0, 0.0, 63.0], [1.0, 0.0, -14.0, 0.0, 21.0, 0.0],
+     [0.0, -1.0, 0.0, 3.0, 0.0, 0.0], [-1.0, 0.0, 9.0, 0.0, 0.0, 0.0],
+     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+    [[-5.0, 0.0, 105.0, 0.0, -315.0, 0.0, 231.0],
+     [0.0, 5.0, 0.0, -30.0, 0.0, 33.0, 0.0],
+     [1.0, 0.0, -18.0, 0.0, 33.0, 0.0, 0.0],
+     [0.0, -3.0, 0.0, 11.0, 0.0, 0.0, 0.0],
+     [-1.0, 0.0, 11.0, 0.0, 0.0, 0.0, 0.0],
+     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+    [[0.0, -35.0, 0.0, 315.0, 0.0, -693.0, 0.0, 429.0],
+     [-5.0, 0.0, 135.0, 0.0, -495.0, 0.0, 429.0, 0.0],
+     [0.0, 15.0, 0.0, -110.0, 0.0, 143.0, 0.0, 0.0],
+     [3.0, 0.0, -66.0, 0.0, 143.0, 0.0, 0.0, 0.0],
+     [0.0, -3.0, 0.0, 13.0, 0.0, 0.0, 0.0, 0.0],
+     [-1.0, 0.0, 13.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+    [[35.0, 0.0, -1260.0, 0.0, 6930.0, 0.0, -12012.0, 0.0, 6435.0],
+     [0.0, -35.0, 0.0, 385.0, 0.0, -1001.0, 0.0, 715.0, 0.0],
+     [-1.0, 0.0, 33.0, 0.0, -143.0, 0.0, 143.0, 0.0, 0.0],
+     [0.0, 3.0, 0.0, -26.0, 0.0, 39.0, 0.0, 0.0, 0.0],
+     [1.0, 0.0, -26.0, 0.0, 65.0, 0.0, 0.0, 0.0, 0.0],
+     [0.0, -1.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+     [-1.0, 0.0, 15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+     [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],
+]
+
+C4B = [-0.007499480826664, -0.134990654879954, 0.067495327439977,
+       0.404971964639861, -0.809943929279723]
+
+C5B = [0.026596810706114, 0.053193621412227, 0.026596810706114]
+
+# Mixed-L invariant (GPUMD NEP feature `has_q_112`).
+C4B2 = [0.027493550848847,
+        0.164961305093080,
+       -0.013746775424423,
+        0.041240326273270,
+        0.082480652546540]
+
+# Higher-L 4-body bispectrum invariants (GPUMD: has_q_123 / has_q_233 / has_q_134).
+C4B_123 = [-0.008418146349617, -0.016836292699234, -0.033672585398469,
+           -0.042090731748086, -0.067345170796937, -0.084181463496172,
+           -0.168362926992344]
+
+C4B_233 = [0.008572620635186, 0.009644198214584, 0.019288396429168,
+           0.025717861905558, 0.026789439484956, 0.032147327381947,
+           0.038576792858337, 0.128589309527790, 0.192883964291685,
+           0.321473273819474]
+
+# q_134 = B(1,3,4): couples L=1, L=3, L=4 moments (GPUMD: has_q_134).
+# Uses L=4 s-moments (lm indices 15..23), so it requires l_max_3b >= 4.
+C4B_134 = [0.003645164295772, 0.004860219061029, 0.006075273826286,
+           0.018225821478859, 0.024301095305146, 0.036451642957719,
+           0.042526916784005, 0.072903285915437, 0.085053833568010,
+           0.255161500704030]
+
+# Each group is (C4B_*[k] index, [(sign, (lm_idx, lm_idx, lm_idx)), ...]),
+# mirroring GPUMD's find_q line by line for easy auditing. Expanded below to
+# the flat (coeff, idx) form consumed by ops._eval_extra / _extra_grad.
+_Q123_GROUPS = [
+    (6, [(+1, (12, 2, 4)), (-1, (11, 2, 5)), (+1, (1, 11, 4)), (+1, (1, 12, 5))]),
+    (5, [(+1, (0, 11, 6)), (+1, (0, 12, 7))]),
+    (3, [(+1, (14, 2, 6)), (-1, (13, 2, 7)), (+1, (1, 13, 6)), (+1, (1, 14, 7))]),
+    (4, [(+1, (10, 0, 5)), (+1, (0, 4, 9))]),
+    (1, [(+1, (10, 2, 3)), (+1, (0, 3, 8)), (+1, (1, 3, 9))]),
+    (0, [(+1, (10, 2, 6)), (-1, (10, 1, 7)), (-1, (2, 7, 9)), (-1, (1, 6, 9))]),
+    (2, [(-1, (2, 5, 8)), (-1, (1, 4, 8))]),
+]
+_Q233_GROUPS = [
+    (0, [(+1, (3, 8, 8))]),
+    (1, [(+1, (10, 10, 3)), (+1, (3, 9, 9))]),
+    (2, [(-1, (10, 10, 6)), (+1, (6, 9, 9))]),
+    (3, [(+1, (4, 8, 9)), (+1, (10, 5, 8))]),
+    (4, [(-1, (13, 13, 3)), (-1, (14, 14, 3))]),
+    (5, [(-1, (14, 7, 9)), (-1, (13, 6, 9)), (-1, (10, 14, 6)), (+1, (10, 13, 7))]),
+    (6, [(+1, (10, 7, 9))]),
+    (7, [(-1, (11, 6, 8)), (-1, (12, 7, 8))]),
+    (8, [(+1, (11, 4, 9)), (+1, (12, 5, 9)), (+1, (10, 12, 4)), (-1, (10, 11, 5))]),
+    (9, [(+1, (12, 14, 4)), (+1, (11, 14, 5)), (+1, (13, 11, 4)), (-1, (13, 12, 5))]),
+]
+_Q134_GROUPS = [
+    (0, [(-1, (10, 15, 2)), (-1, (1, 15, 9))]),
+    (1, [(+1, (0, 15, 8))]),
+    (2, [(-1, (1, 13, 18)), (-1, (1, 14, 19)), (-1, (2, 14, 18)), (+1, (2, 13, 19))]),
+    (3, [(-1, (10, 18, 2)), (+1, (1, 10, 19)), (+1, (1, 18, 9)), (+1, (2, 19, 9))]),
+    (4, [(+1, (1, 16, 8)), (+1, (2, 17, 8))]),
+    (5, [(+1, (0, 10, 17)), (+1, (0, 16, 9)), (-1, (1, 11, 16)), (-1, (1, 12, 17)),
+         (-1, (2, 12, 16)), (+1, (2, 11, 17))]),
+    (6, [(+1, (1, 13, 22)), (+1, (1, 14, 23)), (-1, (2, 14, 22)), (+1, (2, 13, 23))]),
+    (7, [(+1, (0, 11, 18)), (+1, (0, 12, 19))]),
+    (8, [(+1, (0, 13, 20)), (+1, (0, 14, 21))]),
+    (9, [(+1, (1, 11, 20)), (+1, (1, 12, 21)), (-1, (2, 12, 20)), (+1, (2, 11, 21))]),
+]
+Q123_TERMS = [(sign * C4B_123[k], idx)
+              for k, grp in _Q123_GROUPS for sign, idx in grp]
+Q233_TERMS = [(sign * C4B_233[k], idx)
+              for k, grp in _Q233_GROUPS for sign, idx in grp]
+Q134_TERMS = [(sign * C4B_134[k], idx)
+              for k, grp in _Q134_GROUPS for sign, idx in grp]
+
+K_C_SP = 14.399645  # Coulomb constant (eV*Angstrom)
+
+# Unit conversion: 1 eV/A**3 = 160.21766208 GPa  (CODATA 2018 e = 1.602176634e-19 C)
+EV_PER_A3_TO_GPa = 160.21766208
+
+ZBL_PARA = [0.18175, 3.1998, 0.50986, 0.94229, 0.28022, 0.4029, 0.02817, 0.20162]
+
+# Covalent radii in Angstrom, indexed by Z-1.
+#
+# Z = 1–94:   from GPUMD (src/utilities/nep_utilities.cuh::COVALENT_RADIUS),
+#             which stores Grimme's DFT-D3 covalent radii * 4/3 (k2 scaling).
+#             Reference: Grimme, Antony, Ehrlich, Krieg, J. Chem. Phys. 132,
+#             154104 (2010), Table I (itself derived from Pyykkö & Atsumi
+#             2009 with Li/Be/B/etc. empirical adjustments). GPUMD hard-codes
+#             these * 4/3 for ZBL typewise cutoffs; we reproduce them exactly
+#             for bit-compatibility.
+# Z = 95–118: Pyykkö, "Additive Covalent Radii for Single-, Double-, and
+#             Triple-Bonded Molecules and Tetrahedrally Bonded Crystals: A
+#             Summary", J. Phys. Chem. A 119, 2326 (2015), single-bond
+#             radii. Grimme D3 only tabulates up to Z=94 (Pu), so this block
+#             fills the gap from a different reference — there is a minor
+#             scale discontinuity at the Z=94 -> 95 boundary.
+COVALENT_RADIUS = [
+    0.426667, 0.613333, 1.6, 1.25333, 1.02667, 1.0, 0.946667, 0.84,
+    0.853333, 0.893333, 1.86667, 1.66667, 1.50667, 1.38667, 1.46667, 1.36,
+    1.32, 1.28, 2.34667, 2.05333, 1.77333, 1.62667, 1.61333, 1.46667,
+    1.42667, 1.38667, 1.33333, 1.32, 1.34667, 1.45333, 1.49333, 1.45333,
+    1.53333, 1.46667, 1.52, 1.56, 2.52, 2.22667, 1.96, 1.85333,
+    1.76, 1.65333, 1.53333, 1.50667, 1.50667, 1.44, 1.53333, 1.64,
+    1.70667, 1.68, 1.68, 1.64, 1.76, 1.74667, 2.78667, 2.34667,
+    2.16, 1.96, 2.10667, 2.09333, 2.08, 2.06667, 2.01333, 2.02667,
+    2.01333, 2.0, 1.98667, 1.98667, 1.97333, 2.04, 1.94667, 1.82667,
+    1.74667, 1.64, 1.57333, 1.54667, 1.48, 1.49333, 1.50667, 1.76,
+    1.73333, 1.73333, 1.81333, 1.74667, 1.84, 1.89333, 2.68, 2.41333,
+    2.22667, 2.10667, 2.02667, 2.04, 2.05333, 2.06667,
+    # Pyykkö 2015 single-bond values (see note above the table).
+    1.80, 1.69, 1.68, 1.68, 1.65, 1.67, 1.73, 1.76, 1.61,   # Am-Lr
+    1.57, 1.49, 1.43, 1.41, 1.34, 1.29, 1.28, 1.21, 1.22,   # Rf-Cn
+    1.36, 1.43, 1.62, 1.75, 1.65, 1.57,                       # Nh-Og
+]
+assert len(COVALENT_RADIUS) == 118