pymdkit 1.2.12__tar.gz → 1.3.0__tar.gz

{pymdkit-1.2.12/src/pymdkit.egg-info → pymdkit-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.2.12
+Version: 1.3.0
 Summary: A unified command-line toolkit for atomistic / MD structure workflows.
 Author-email: Yueda Wang <ydwang0608@ustc.edu.cn>
 License-Expression: GPL-3.0-or-later
@@ -17,6 +17,7 @@ Requires-Dist: numpy
 Requires-Dist: ase
 Requires-Dist: pymatgen
 Requires-Dist: mp-api
+Requires-Dist: py4vasp-core
 Requires-Dist: pyxtal
 Requires-Dist: dpdata
 Dynamic: license-file
@@ -66,7 +67,7 @@ directory for job sub-folders automatically.
 | `final-energy` | List VASP job final energies from lowest to highest |
 | `gather-contcar` | Collect CONTCARs from VASP job folders into one folder, renamed `<folder>.vasp` |
 | `msd` | Diffusivity & conductivity from GPUMD MSD jobs (auto-scans `<structure>/<temp>/`) |
-| `nep-rmse` | Compute NEP energy/force/stress RMSE with ASCII plots and optional candidate selection |
+| `nep-rmse` | Compute NEP energy/force/stress RMSE with terminal plots and optional candidate selection |
 | `perturb` | Generate perturbed structures with dpdata |
 | `vasp2xyz` | Collect SCF-converged VASP job folders (any name) into one extxyz file |
 | `submit-vasp` | Submit/resubmit VASP job folders while limiting active queue jobs |
@@ -116,7 +117,7 @@ pymdkit substitute -i Li96Ta6La11Cl72.cif -se Li2 -we none -ref La Ta
 pymdkit electrostatic-energy -i Li3YCl6.cif
 pymdkit electrostatic-energy -if Li3YCl6-all
 pymdkit nep-rmse                                    # writes energy/force/stress train txt files, rmse_value.txt, and terminal plots
-pymdkit nep-rmse -select-candidate -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
+pymdkit nep-rmse -select -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
 pymdkit perturb -i example.xyz -atom 0.2 -lattice 0.03 -n 100 -o example-perturb-atom-0.2-lattice-0.03.xyz
 
 pymdkit rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt

{pymdkit-1.2.12 → pymdkit-1.3.0}/README.md

@@ -43,7 +43,7 @@ directory for job sub-folders automatically.
 | `final-energy` | List VASP job final energies from lowest to highest |
 | `gather-contcar` | Collect CONTCARs from VASP job folders into one folder, renamed `<folder>.vasp` |
 | `msd` | Diffusivity & conductivity from GPUMD MSD jobs (auto-scans `<structure>/<temp>/`) |
-| `nep-rmse` | Compute NEP energy/force/stress RMSE with ASCII plots and optional candidate selection |
+| `nep-rmse` | Compute NEP energy/force/stress RMSE with terminal plots and optional candidate selection |
 | `perturb` | Generate perturbed structures with dpdata |
 | `vasp2xyz` | Collect SCF-converged VASP job folders (any name) into one extxyz file |
 | `submit-vasp` | Submit/resubmit VASP job folders while limiting active queue jobs |
@@ -93,7 +93,7 @@ pymdkit substitute -i Li96Ta6La11Cl72.cif -se Li2 -we none -ref La Ta
 pymdkit electrostatic-energy -i Li3YCl6.cif
 pymdkit electrostatic-energy -if Li3YCl6-all
 pymdkit nep-rmse                                    # writes energy/force/stress train txt files, rmse_value.txt, and terminal plots
-pymdkit nep-rmse -select-candidate -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
+pymdkit nep-rmse -select -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
 pymdkit perturb -i example.xyz -atom 0.2 -lattice 0.03 -n 100 -o example-perturb-atom-0.2-lattice-0.03.xyz
 
 pymdkit rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt

{pymdkit-1.2.12 → pymdkit-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pymdkit"
-version = "1.2.12"
+version = "1.3.0"
 description = "A unified command-line toolkit for atomistic / MD structure workflows."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -28,6 +28,7 @@ dependencies = [
     "ase",
     "pymatgen",
     "mp-api",
+    "py4vasp-core",
     "pyxtal",
     "dpdata",
 ]

{pymdkit-1.2.12 → pymdkit-1.3.0}/src/pymdkit/__init__.py

@@ -1,3 +1,3 @@
 """pymdkit -- a unified CLI for atomistic / MD structure workflows."""
 
-__version__ = "1.2.12"
+__version__ = "1.3.0"

pymdkit-1.3.0/src/pymdkit/commands/_vasp_output.py

@@ -0,0 +1,397 @@
+"""Shared VASP output readers.
+
+Reader priority is always:
+
+    vaspout.h5 > vasprun.xml > OUTCAR
+
+Commands that extract properties from VASP outputs should use this helper so
+newer vaspout.h5 files are preferred consistently across pymdkit.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+from pathlib import Path
+
+
+@dataclass
+class VaspOutput:
+    folder: Path
+    source: str
+    parser: object
+
+    @property
+    def final_energy(self):
+        return getattr(self.parser, "final_energy")
+
+    @property
+    def final_structure(self):
+        return getattr(self.parser, "final_structure", None)
+
+    @property
+    def ionic_steps(self):
+        return getattr(self.parser, "ionic_steps", [])
+
+    @property
+    def converged_electronic(self):
+        return bool(getattr(self.parser, "converged_electronic", False))
+
+    @property
+    def converged(self):
+        return bool(getattr(self.parser, "converged", self.converged_electronic))
+
+    def get_computed_entry(self, inc_structure=True, entry_id=None):
+        if not hasattr(self.parser, "get_computed_entry"):
+            from pymatgen.entries.computed_entries import ComputedStructureEntry
+
+            structure = self.final_structure
+            if structure is None:
+                structure_file = None
+                for name in ("CONTCAR", "POSCAR"):
+                    candidate = self.folder / name
+                    if candidate.exists():
+                        structure_file = candidate
+                        break
+                if structure_file is None:
+                    raise AttributeError("get_computed_entry")
+                structure = _read_structure(structure_file)
+            return ComputedStructureEntry(
+                structure=structure,
+                energy=self.final_energy,
+                parameters={"run_type": "GGA"},
+                entry_id=entry_id or self.folder.name,
+            )
+
+        entry = self.parser.get_computed_entry(
+            inc_structure=inc_structure,
+            entry_id=entry_id or self.folder.name,
+        )
+        if entry.parameters.get("run_type") == "PBE":
+            entry.parameters["run_type"] = "GGA"
+        return entry
+
+
+def _read_structure(path):
+    from pymatgen.core import Structure
+
+    return Structure.from_file(str(path))
+
+
+class OutcarAdapter:
+    """Small adapter for the limited properties available from OUTCAR alone."""
+
+    def __init__(self, path):
+        from pymatgen.io.vasp.outputs import Outcar
+
+        self.path = Path(path)
+        self.outcar = Outcar(str(path))
+        self._text = self.path.read_text(errors="ignore")
+
+    @property
+    def final_energy(self):
+        for attr in ("final_energy", "final_fr_energy", "final_energy_wo_entrp"):
+            if hasattr(self.outcar, attr):
+                value = getattr(self.outcar, attr)
+                if value is not None:
+                    return value
+        raise AttributeError("final_energy")
+
+    @property
+    def ionic_steps(self):
+        return []
+
+    @property
+    def final_structure(self):
+        return None
+
+    @property
+    def converged_electronic(self):
+        markers = (
+            "aborting loop because EDIFF is reached",
+            "reached required accuracy",
+        )
+        return any(marker in self._text for marker in markers)
+
+    @property
+    def converged(self):
+        return (self.converged_electronic
+                and "reached required accuracy" in self._text)
+
+
+
+def _last_scalar(value):
+    try:
+        import numpy as np
+    except ImportError:
+        np = None
+
+    if np is not None:
+        try:
+            array = np.asarray(value, dtype=float)
+        except (TypeError, ValueError):
+            return None
+        if array.size == 0:
+            return None
+        return float(array.reshape(-1)[-1])
+    if isinstance(value, (int, float)) and math.isfinite(value):
+        return float(value)
+    if isinstance(value, (list, tuple)) and value:
+        return _last_scalar(value[-1])
+    return None
+
+
+def _find_scalar_quantity(data, names):
+    if isinstance(data, dict):
+        for name in names:
+            if name in data:
+                value = _last_scalar(data[name])
+                if value is not None:
+                    return value
+        for value in data.values():
+            found = _find_scalar_quantity(value, names)
+            if found is not None:
+                return found
+    elif isinstance(data, (list, tuple)):
+        for value in reversed(data):
+            found = _find_scalar_quantity(value, names)
+            if found is not None:
+                return found
+    return None
+def _last_numeric_array(value):
+    try:
+        import numpy as np
+    except ImportError:
+        np = None
+
+    if np is not None:
+        try:
+            array = np.asarray(value, dtype=float)
+        except (TypeError, ValueError):
+            return None
+        if array.size == 0:
+            return None
+        while array.ndim > 2 and array.shape[0] > 0:
+            array = array[-1]
+        if array.ndim == 0:
+            return float(array)
+        return array.tolist()
+
+    if isinstance(value, (int, float)) and math.isfinite(value):
+        return float(value)
+    if isinstance(value, (list, tuple)) and value:
+        return _last_numeric_array(value[-1])
+    return None
+
+
+def _find_quantity(data, names):
+    if isinstance(data, dict):
+        for name in names:
+            if name in data:
+                value = _last_numeric_array(data[name])
+                if value is not None:
+                    return value
+        for value in data.values():
+            found = _find_quantity(value, names)
+            if found is not None:
+                return found
+    elif isinstance(data, (list, tuple)):
+        for value in reversed(data):
+            found = _find_quantity(value, names)
+            if found is not None:
+                return found
+    return None
+
+
+
+def _last_stress_array(value):
+    try:
+        import numpy as np
+    except ImportError:
+        np = None
+
+    if np is not None:
+        try:
+            array = np.asarray(value, dtype=float)
+        except (TypeError, ValueError):
+            return None
+        if array.size == 0:
+            return None
+        while array.ndim > 2 and array.shape[0] > 0:
+            array = array[-1]
+        if array.ndim == 2 and array.shape[1] in (6, 9):
+            array = array[-1]
+        if array.ndim == 0:
+            return float(array)
+        return array.tolist()
+
+    if isinstance(value, (int, float)) and math.isfinite(value):
+        return float(value)
+    if isinstance(value, (list, tuple)) and value:
+        if value and isinstance(value[0], (list, tuple)) and len(value[0]) in (6, 9):
+            return _last_stress_array(value[-1])
+        return _last_stress_array(value[-1])
+    return None
+
+
+def _find_stress_quantity(data, names):
+    if isinstance(data, dict):
+        for name in names:
+            if name in data:
+                value = _last_stress_array(data[name])
+                if value is not None:
+                    return value
+        for value in data.values():
+            found = _find_stress_quantity(value, names)
+            if found is not None:
+                return found
+    elif isinstance(data, (list, tuple)):
+        for value in reversed(data):
+            found = _find_stress_quantity(value, names)
+            if found is not None:
+                return found
+    return None
+class Py4VaspAdapter:
+    """Adapter for reading vaspout.h5 with the official py4vasp package."""
+
+    def __init__(self, path):
+        import py4vasp
+
+        self.path = Path(path)
+        self.folder = self.path.parent
+        self.calculation = py4vasp.Calculation.from_path(str(self.folder))
+        self._final_energy = None
+        self._final_structure = None
+        self._ionic_steps = None
+
+    @property
+    def final_energy(self):
+        if self._final_energy is None:
+            data = self.calculation.energy.to_dict()
+            value = _find_scalar_quantity(data, (
+                "free energy    TOTEN",
+                "free_energy",
+                "free energy",
+                "energy",
+                "total",
+            ))
+            if value is None:
+                raise AttributeError("final_energy")
+            self._final_energy = value
+        return self._final_energy
+
+    @property
+    def final_structure(self):
+        if self._final_structure is None:
+            from pymatgen.io.ase import AseAtomsAdaptor
+
+            structure = self.calculation.structure
+            atoms = None
+            for getter in (
+                    lambda: structure.to_ase(),
+                    lambda: structure[-1].to_ase(),
+                    lambda: structure[:].to_ase()[-1],
+            ):
+                try:
+                    atoms = getter()
+                    break
+                except Exception:
+                    continue
+            if atoms is None:
+                raise AttributeError("final_structure")
+            self._final_structure = AseAtomsAdaptor.get_structure(atoms)
+        return self._final_structure
+
+    @property
+    def ionic_steps(self):
+        if self._ionic_steps is None:
+            step = {}
+            try:
+                force_data = self.calculation.force.to_dict()
+                forces = _find_quantity(force_data, ("forces", "force"))
+                if forces is not None:
+                    step["forces"] = forces
+            except Exception:
+                pass
+            try:
+                stress_data = self.calculation.stress.to_dict()
+                stress = _find_stress_quantity(stress_data, ("stress", "stresses"))
+                if stress is not None:
+                    step["stress"] = stress
+            except Exception:
+                pass
+            self._ionic_steps = [step] if step else []
+        return self._ionic_steps
+
+    @property
+    def converged_electronic(self):
+        outcar = self.folder / "OUTCAR"
+        if outcar.exists():
+            try:
+                return OutcarAdapter(outcar).converged_electronic
+            except Exception:
+                pass
+        return True
+
+    @property
+    def converged(self):
+        outcar = self.folder / "OUTCAR"
+        if outcar.exists():
+            try:
+                return OutcarAdapter(outcar).converged
+            except Exception:
+                pass
+        return self.converged_electronic
+
+
+def _parse_vaspout(path):
+    return Py4VaspAdapter(path)
+
+
+def _parse_vasprun(path):
+    from pymatgen.io.vasp.outputs import Vasprun
+
+    return Vasprun(str(path), parse_dos=False, parse_eigen=False)
+
+
+def _parse_outcar(path):
+    return OutcarAdapter(path)
+
+
+def read_vasp_output(folder, require=("final_energy",)):
+    """Read the best available VASP output in *folder*.
+
+    Args:
+        folder: VASP job folder.
+        require: Attribute names that must be available on the parser.
+
+    Returns:
+        VaspOutput or None if no parser can provide the requested properties.
+    """
+    folder = Path(folder)
+    candidates = (
+        ("vaspout.h5", _parse_vaspout),
+        ("vasprun.xml", _parse_vasprun),
+        ("OUTCAR", _parse_outcar),
+    )
+    for filename, parser_fn in candidates:
+        path = folder / filename
+        if not path.exists():
+            continue
+        try:
+            parser = parser_fn(path)
+            output = VaspOutput(folder=folder, source=filename, parser=parser)
+            for attr in require:
+                value = getattr(output, attr)
+                if value is None:
+                    raise AttributeError(attr)
+            return output
+        except Exception:
+            continue
+    return None
+
+
+def has_vasp_output(folder):
+    folder = Path(folder)
+    return any((folder / name).exists()
+               for name in ("vaspout.h5", "vasprun.xml", "OUTCAR", "CONTCAR"))

{pymdkit-1.2.12 → pymdkit-1.3.0}/src/pymdkit/commands/nep_rmse.py

@@ -1,4 +1,4 @@
-"""Compute and ASCII-plot NEP train RMSE for energy, force, and stress."""
+"""Compute and terminal-plot NEP train RMSE for energy, force, and stress."""
 
 from __future__ import annotations
 
@@ -7,7 +7,7 @@ import math
 from pathlib import Path
 
 COMMAND = "nep-rmse"
-HELP = "Compute NEP energy/force/stress RMSE and draw ASCII plots."
+HELP = "Compute NEP energy/force/stress RMSE and draw terminal plots."
 
 
 def add_arguments(parser: argparse.ArgumentParser) -> None:
@@ -18,10 +18,12 @@ def add_arguments(parser: argparse.ArgumentParser) -> None:
                         help="NEP force_train.out file.")
     parser.add_argument("-stress-train", dest="stress_train", default="stress_train.out",
                         help="NEP stress_train.out file.")
-    parser.add_argument("-select-candidate", action="store_true",
+    parser.add_argument("-select", dest="select_candidate", action="store_true",
                         help="Interactively select candidate structures from train.xyz.")
+    parser.add_argument("-select-candidate", dest="select_candidate",
+                        action="store_true", help=argparse.SUPPRESS)
     parser.add_argument("-xyz", default="train.xyz",
-                        help="Training trajectory for -select-candidate mode.")
+                        help="Training trajectory for -select mode.")
 
 
 def load_training(args):
@@ -101,7 +103,10 @@ def write_rmse_report(sections):
 def axis_range(*tables):
     import numpy as np
 
-    merged = np.vstack([t for t in tables if t is not None and len(t)])
+    available = [t for t in tables if t is not None and len(t)]
+    if not available:
+        return -1.0, 1.0
+    merged = np.vstack(available)
     lo = float(np.min(merged))
     hi = float(np.max(merged))
     pad = 0.1 * (hi - lo) if hi > lo else 1.0
@@ -116,54 +121,45 @@ def metric_value(metric, vals):
     return vals["stress_GPa"], "GPa", 4
 
 
-def ascii_terminal_plot(metric, title, xlabel, ylabel, table,
-                        all_vals, candidate_table=None, accurate_table=None,
-                        candidate_vals=None, accurate_vals=None,
-                        width=72, height=22):
-    xmin, xmax = axis_range(table, candidate_table, accurate_table)
-    grid = [[" " for _ in range(width)] for _ in range(height)]
+def _place_point(grid, x, y, xmin, xmax, marker):
+    width = len(grid[0])
+    height = len(grid)
+    if xmax == xmin:
+        return
+    col = int(round((x - xmin) / (xmax - xmin) * (width - 1)))
+    row = int(round((xmax - y) / (xmax - xmin) * (height - 1)))
+    if 0 <= row < height and 0 <= col < width:
+        grid[row][col] = marker
 
-    def place(x, y, char):
-        if xmax == xmin:
-            return
-        col = int(round((x - xmin) / (xmax - xmin) * (width - 1)))
-        row = int(round((xmax - y) / (xmax - xmin) * (height - 1)))
-        if 0 <= row < height and 0 <= col < width:
-            grid[row][col] = char
-
-    for i in range(width):
-        x = xmin + (xmax - xmin) * i / max(width - 1, 1)
-        place(x, x, "/")
 
+def _plot_panel(table, candidate_table=None, accurate_table=None,
+                width=56, height=18):
+    xmin, xmax = axis_range(table, candidate_table, accurate_table)
+    grid = [[" " for _ in range(width)] for _ in range(height)]
     if candidate_table is not None or accurate_table is not None:
         if accurate_table is not None:
             for x, y in accurate_table:
-                place(x, y, "o")
+                _place_point(grid, x, y, xmin, xmax, "\u25CB")
         if candidate_table is not None:
             for x, y in candidate_table:
-                place(x, y, ".")
-        legend = ".=candidate, o=accurate, /=DFT=NEP"
+                _place_point(grid, x, y, xmin, xmax, "\u25CF")
     else:
         for x, y in table:
-            place(x, y, "o")
-        legend = "o=all, /=DFT=NEP"
-
-    value, unit, prec = metric_value(metric, all_vals)
-    title_line = f"{title} RMSE: all {value:.{prec}f} {unit}"
-    if candidate_vals is not None and accurate_vals is not None:
-        cand, _, _ = metric_value(metric, candidate_vals)
-        acc, _, _ = metric_value(metric, accurate_vals)
-        title_line += f"; candidate {cand:.{prec}f}; accurate {acc:.{prec}f}"
-
-    print(f"\n{title} RMSE plot")
-    print(title_line)
-    print(f"y: {ylabel}")
-    print("+" + "-" * width + "+")
-    for row in grid:
-        print("|" + "".join(row) + "|")
-    print("+" + "-" * width + "+")
-    print(f"x: {xlabel}")
-    print(f"range: {xmin:.6g} to {xmax:.6g}; {legend}")
+            _place_point(grid, x, y, xmin, xmax, "\u25CB")
+    return ["".join(row) for row in grid]
+
+
+def _rmse_plot_title(all_vals, candidate_vals=None, accurate_vals=None):
+    parts = []
+    for metric, label in (("energy", "Energy"), ("force", "Force"), ("stress", "Stress")):
+        value, unit, prec = metric_value(metric, all_vals)
+        text = f"{label}: all {value:.{prec}f} {unit}"
+        if candidate_vals is not None and accurate_vals is not None:
+            cand, _, _ = metric_value(metric, candidate_vals)
+            acc, _, _ = metric_value(metric, accurate_vals)
+            text += f", selected {cand:.{prec}f}, unselected {acc:.{prec}f}"
+        parts.append(text)
+    return " | ".join(parts)
 
 
 def plot_rmse(all_vals, energy_txt, force_txt, stress_txt,
@@ -171,19 +167,18 @@ def plot_rmse(all_vals, energy_txt, force_txt, stress_txt,
               candidate_vals=None, accurate_vals=None):
     candidate_tables = candidate_tables or {}
     accurate_tables = accurate_tables or {}
-    ascii_terminal_plot(
-        "energy", "Energy", "DFT energy (eV/atom)", "NEP energy (eV/atom)",
-        energy_txt, all_vals, candidate_tables.get("energy"), accurate_tables.get("energy"),
-        candidate_vals, accurate_vals)
-    ascii_terminal_plot(
-        "force", "Force", "DFT force (eV/A)", "NEP force (eV/A)",
-        force_txt, all_vals, candidate_tables.get("force"), accurate_tables.get("force"),
-        candidate_vals, accurate_vals)
-    ascii_terminal_plot(
-        "stress", "Stress", "DFT stress (GPa)", "NEP stress (GPa)",
-        stress_txt, all_vals, candidate_tables.get("stress"), accurate_tables.get("stress"),
-        candidate_vals, accurate_vals)
-
+    panels = [
+        _plot_panel(energy_txt, candidate_tables.get("energy"), accurate_tables.get("energy")),
+        _plot_panel(force_txt, candidate_tables.get("force"), accurate_tables.get("force")),
+        _plot_panel(stress_txt, candidate_tables.get("stress"), accurate_tables.get("stress")),
+    ]
+    width = len(panels[0][0])
+    print("\nNEP RMSE plot")
+    print(_rmse_plot_title(all_vals, candidate_vals, accurate_vals))
+    print("\u250C" + ("\u2500" * width) + "\u252C" + ("\u2500" * width) + "\u252C" + ("\u2500" * width) + "\u2510")
+    for row in range(len(panels[0])):
+        print("\u2502" + panels[0][row] + "\u2502" + panels[1][row] + "\u2502" + panels[2][row] + "\u2502")
+    print("\u2514" + ("\u2500" * width) + "\u2534" + ("\u2500" * width) + "\u2534" + ("\u2500" * width) + "\u2518")
 
 def frame_atom_slices(frames):
     slices = []
@@ -203,19 +198,37 @@ def select_indices(energy_txt, proportion):
     return np.sort(order[:n_candidate]), np.sort(order[n_candidate:])
 
 
+def _equal_frame_rows(table, frames, label):
+    if len(frames) == 0:
+        return []
+    if len(table) % len(frames) != 0:
+        raise ValueError(
+            f"{label} rows ({len(table)}) cannot be divided among "
+            f"{len(frames)} structures for selection mode")
+    rows_per_frame = len(table) // len(frames)
+    return [slice(i * rows_per_frame, (i + 1) * rows_per_frame)
+            for i in range(len(frames))]
+
+
+def _rows_from_slices(slices, indices):
+    rows = []
+    for idx in indices:
+        rows.extend(range(slices[idx].start, slices[idx].stop))
+    return rows
+
+
 def subset_tables(energy_txt, force_txt, stress_txt, frames, indices):
     import numpy as np
 
     atom_slices = frame_atom_slices(frames)
-    if len(stress_txt) != len(energy_txt):
-        raise ValueError("stress_train rows must match energy_train rows for selection mode")
-    force_rows = []
-    for idx in indices:
-        force_rows.extend(range(atom_slices[idx].start * 3, atom_slices[idx].stop * 3))
+    force_slices = [slice(s.start * 3, s.stop * 3) for s in atom_slices]
+    stress_slices = _equal_frame_rows(stress_txt, frames, "stress_train")
+    force_rows = _rows_from_slices(force_slices, indices)
+    stress_rows = _rows_from_slices(stress_slices, indices)
     return (
         energy_txt[indices],
         force_txt[force_rows] if force_rows else np.empty((0, 2)),
-        stress_txt[indices],
+        stress_txt[stress_rows] if stress_rows else np.empty((0, 2)),
     )
 
 

{pymdkit-1.2.12 → pymdkit-1.3.0/src/pymdkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.2.12
+Version: 1.3.0
 Summary: A unified command-line toolkit for atomistic / MD structure workflows.
 Author-email: Yueda Wang <ydwang0608@ustc.edu.cn>
 License-Expression: GPL-3.0-or-later
@@ -17,6 +17,7 @@ Requires-Dist: numpy
 Requires-Dist: ase
 Requires-Dist: pymatgen
 Requires-Dist: mp-api
+Requires-Dist: py4vasp-core
 Requires-Dist: pyxtal
 Requires-Dist: dpdata
 Dynamic: license-file
@@ -66,7 +67,7 @@ directory for job sub-folders automatically.
 | `final-energy` | List VASP job final energies from lowest to highest |
 | `gather-contcar` | Collect CONTCARs from VASP job folders into one folder, renamed `<folder>.vasp` |
 | `msd` | Diffusivity & conductivity from GPUMD MSD jobs (auto-scans `<structure>/<temp>/`) |
-| `nep-rmse` | Compute NEP energy/force/stress RMSE with ASCII plots and optional candidate selection |
+| `nep-rmse` | Compute NEP energy/force/stress RMSE with terminal plots and optional candidate selection |
 | `perturb` | Generate perturbed structures with dpdata |
 | `vasp2xyz` | Collect SCF-converged VASP job folders (any name) into one extxyz file |
 | `submit-vasp` | Submit/resubmit VASP job folders while limiting active queue jobs |
@@ -116,7 +117,7 @@ pymdkit substitute -i Li96Ta6La11Cl72.cif -se Li2 -we none -ref La Ta
 pymdkit electrostatic-energy -i Li3YCl6.cif
 pymdkit electrostatic-energy -if Li3YCl6-all
 pymdkit nep-rmse                                    # writes energy/force/stress train txt files, rmse_value.txt, and terminal plots
-pymdkit nep-rmse -select-candidate -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
+pymdkit nep-rmse -select -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
 pymdkit perturb -i example.xyz -atom 0.2 -lattice 0.03 -n 100 -o example-perturb-atom-0.2-lattice-0.03.xyz
 
 pymdkit rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt

{pymdkit-1.2.12 → pymdkit-1.3.0}/src/pymdkit.egg-info/requires.txt

@@ -2,5 +2,6 @@ numpy
 ase
 pymatgen
 mp-api
+py4vasp-core
 pyxtal
 dpdata

pymdkit-1.2.12/src/pymdkit/commands/_vasp_output.py

@@ -1,174 +0,0 @@
-"""Shared VASP output readers.
-
-Reader priority is always:
-
-    vaspout.h5 > vasprun.xml > OUTCAR
-
-Commands that extract properties from VASP outputs should use this helper so
-newer vaspout.h5 files are preferred consistently across pymdkit.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass
-class VaspOutput:
-    folder: Path
-    source: str
-    parser: object
-
-    @property
-    def final_energy(self):
-        return getattr(self.parser, "final_energy")
-
-    @property
-    def final_structure(self):
-        return getattr(self.parser, "final_structure", None)
-
-    @property
-    def ionic_steps(self):
-        return getattr(self.parser, "ionic_steps", [])
-
-    @property
-    def converged_electronic(self):
-        return bool(getattr(self.parser, "converged_electronic", False))
-
-    @property
-    def converged(self):
-        return bool(getattr(self.parser, "converged", self.converged_electronic))
-
-    def get_computed_entry(self, inc_structure=True, entry_id=None):
-        if not hasattr(self.parser, "get_computed_entry"):
-            from pymatgen.entries.computed_entries import ComputedStructureEntry
-
-            structure_file = None
-            for name in ("CONTCAR", "POSCAR"):
-                candidate = self.folder / name
-                if candidate.exists():
-                    structure_file = candidate
-                    break
-            if structure_file is None:
-                raise AttributeError("get_computed_entry")
-            structure = _read_structure(structure_file)
-            return ComputedStructureEntry(
-                structure=structure,
-                energy=self.final_energy,
-                parameters={"run_type": "GGA"},
-                entry_id=entry_id or self.folder.name,
-            )
-
-        entry = self.parser.get_computed_entry(
-            inc_structure=inc_structure,
-            entry_id=entry_id or self.folder.name,
-        )
-        if entry.parameters.get("run_type") == "PBE":
-            entry.parameters["run_type"] = "GGA"
-        return entry
-
-
-def _read_structure(path):
-    from pymatgen.core import Structure
-
-    return Structure.from_file(str(path))
-
-
-class OutcarAdapter:
-    """Small adapter for the limited properties available from OUTCAR alone."""
-
-    def __init__(self, path):
-        from pymatgen.io.vasp.outputs import Outcar
-
-        self.path = Path(path)
-        self.outcar = Outcar(str(path))
-        self._text = self.path.read_text(errors="ignore")
-
-    @property
-    def final_energy(self):
-        for attr in ("final_energy", "final_fr_energy", "final_energy_wo_entrp"):
-            if hasattr(self.outcar, attr):
-                value = getattr(self.outcar, attr)
-                if value is not None:
-                    return value
-        raise AttributeError("final_energy")
-
-    @property
-    def ionic_steps(self):
-        return []
-
-    @property
-    def final_structure(self):
-        return None
-
-    @property
-    def converged_electronic(self):
-        markers = (
-            "aborting loop because EDIFF is reached",
-            "reached required accuracy",
-        )
-        return any(marker in self._text for marker in markers)
-
-    @property
-    def converged(self):
-        return (self.converged_electronic
-                and "reached required accuracy" in self._text)
-
-
-def _parse_vaspout(path):
-    from pymatgen.io.vasp.outputs import Vaspout
-
-    try:
-        return Vaspout(str(path), parse_dos=False, parse_eigen=False)
-    except TypeError:
-        return Vaspout(str(path))
-
-
-def _parse_vasprun(path):
-    from pymatgen.io.vasp.outputs import Vasprun
-
-    return Vasprun(str(path), parse_dos=False, parse_eigen=False)
-
-
-def _parse_outcar(path):
-    return OutcarAdapter(path)
-
-
-def read_vasp_output(folder, require=("final_energy",)):
-    """Read the best available VASP output in *folder*.
-
-    Args:
-        folder: VASP job folder.
-        require: Attribute names that must be available on the parser.
-
-    Returns:
-        VaspOutput or None if no parser can provide the requested properties.
-    """
-    folder = Path(folder)
-    candidates = (
-        ("vaspout.h5", _parse_vaspout),
-        ("vasprun.xml", _parse_vasprun),
-        ("OUTCAR", _parse_outcar),
-    )
-    for filename, parser_fn in candidates:
-        path = folder / filename
-        if not path.exists():
-            continue
-        try:
-            parser = parser_fn(path)
-            output = VaspOutput(folder=folder, source=filename, parser=parser)
-            for attr in require:
-                value = getattr(output, attr)
-                if value is None:
-                    raise AttributeError(attr)
-            return output
-        except Exception:
-            continue
-    return None
-
-
-def has_vasp_output(folder):
-    folder = Path(folder)
-    return any((folder / name).exists()
-               for name in ("vaspout.h5", "vasprun.xml", "OUTCAR", "CONTCAR"))