pymdkit 1.4.0__tar.gz → 1.4.1__tar.gz

{pymdkit-1.4.0/src/pymdkit.egg-info → pymdkit-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.4.0
+Version: 1.4.1
 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
@@ -69,6 +69,7 @@ directory for job sub-folders automatically.
 | `vasp-fe` | List VASP job final energies from lowest to highest |
 | `gather-contcar` | Collect CONTCARs from VASP job folders into one folder, renamed `<folder>.vasp` |
 | `gpumd-thermo` | Export and plot GPUMD thermo data and detect sustained equilibrium changes |
+| `gpumd-trjcat` | Merge trajectories from GPUMD jobs with stable equilibrium thermo data |
 | `pca` | Reduce descriptor data to two dimensions; optional FPS sampling |
 | `trj-extract` | Extract a GPUMD XYZ trajectory by time range |
 | `umap` | Reduce descriptor data to two dimensions with UMAP; optional FPS sampling |
@@ -125,11 +126,13 @@ pmk ewald -if Li3YCl6-all
 pmk nep-rmse                                    # writes energy/force/stress train txt files, rmse_value.txt, and terminal plots
 pmk nep-rmse -select -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
 pmk perturb -i example.xyz -atom 0.2 -lattice 0.03 -n 100 -o example-perturb-atom-0.2-lattice-0.03.xyz
-pmk pca -i descriptor.out -o pca-descriptor.txt
+pmk pca -i descriptor.out -o pca-descriptor.txt -it train.xyz  # also split descriptors by Config_type
 pmk pca -i descriptor.out -o pca-descriptor.txt -fps 0.01 -it train.xyz
 pmk umap -i descriptor.out -o umap-descriptor.txt -fps 0.01 -it train.xyz
 pmk gpumd-thermo                              # current job, or recursively scan job folders
 pmk gpumd-thermo -t thermo.out -in run.in
+pmk gpumd-trjcat                            # stable ./<job>/traj.xyz files -> train.xyz
+pmk gpumd-trjcat -i traj.xyz -o train.xyz
 pmk trj-extract -it traj.xyz -in run.in -b 100 -e 200 -o traj-100ps-200ps.xyz
 
 pmk rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt
@@ -163,10 +166,14 @@ folder also keeps a `frame_N.xyz`, so `Config_type` survives for a later
 
 `nep-rmse -select`, PCA FPS, and UMAP FPS copy selected extended-XYZ frame blocks directly from the input trajectory. No parser rewrites energy, stress, forces, positions, precision, or extra metadata.
 
+When `pca` or `umap` receives `-it train.xyz`, it reads `Config_type` from every frame and writes one additional descriptor table per value, such as `pca-descriptor-P-3m1.txt` and `pca-descriptor-Pnma.txt`. With `-fps`, it also writes matching files such as `fps-0.01-pca-descriptor-P-3m1.txt` and `fps-0.01-train-P-3m1.xyz`. These files partition the single global FPS selection; FPS is not rerun independently for each `Config_type`. Frames without `Config_type` remain in the main outputs but do not receive a type-specific file.
+
 For folder conversion, `convert -if INPUT -of OUTPUT` writes `.xyz` by default. Set another target extension with `-oe`, for example `-oe cif` or `-oe vasp`. Single-file and trajectory modes infer the target format from `-o` and `-ot`.
 
 `gpumd-thermo` writes `temperature.txt`, `potential-energy.txt`, `pressure.txt`, `lattice-parameters.txt`, `volume.txt`, `lattice-angles.txt`, and a headless `thermo.png` in every detected GPUMD job folder. Its warning is a numerical reminder based on sustained drift or a level shift in the last `run` segment (or the last 80% when `run.in` has no `run` record); inspect the plot before deciding whether a trajectory is equilibrated.
 
+`gpumd-trjcat` recursively scans job subfolders for `traj.xyz`, `thermo.out`, and `run.in`. Jobs with missing, unreadable, or abnormal thermo data are skipped. Stable trajectories are merged in deterministic folder order. When `<job>/model.xyz` contains `Config_type`, that value is applied to every frame from the job while all other extended-XYZ bytes remain unchanged.
+
 Each command's full flag list is in `pmk <command> -help`.
 
 For long VASP batch submission, run `submit-vasp` with `nohup` and `&` if you
@@ -208,8 +215,12 @@ pymdkit/
     |-- pymdkit_main.py         # dispatcher: discovers and runs commands
     `-- commands/               # one module per command
         |-- _fileio.py          # shared -i/-o/-if/-of helper (not a command)
+        |-- _gpumd.py           # shared GPUMD run.in and thermo analysis
+        |-- _geometry.py        # shared minimum-image geometry helper
         |-- _vaspset.py         # shared VASP input-set helper (not a command)
         |-- gpumd_group.py
+        |-- gpumd_thermo.py
+        |-- gpumd_trjcat.py
         |-- compute_ehull.py
         |-- compute_rmsd.py
         |-- ewald.py

{pymdkit-1.4.0 → pymdkit-1.4.1}/README.md

@@ -43,6 +43,7 @@ directory for job sub-folders automatically.
 | `vasp-fe` | List VASP job final energies from lowest to highest |
 | `gather-contcar` | Collect CONTCARs from VASP job folders into one folder, renamed `<folder>.vasp` |
 | `gpumd-thermo` | Export and plot GPUMD thermo data and detect sustained equilibrium changes |
+| `gpumd-trjcat` | Merge trajectories from GPUMD jobs with stable equilibrium thermo data |
 | `pca` | Reduce descriptor data to two dimensions; optional FPS sampling |
 | `trj-extract` | Extract a GPUMD XYZ trajectory by time range |
 | `umap` | Reduce descriptor data to two dimensions with UMAP; optional FPS sampling |
@@ -99,11 +100,13 @@ pmk ewald -if Li3YCl6-all
 pmk nep-rmse                                    # writes energy/force/stress train txt files, rmse_value.txt, and terminal plots
 pmk nep-rmse -select -xyz train.xyz   # interactive candidate selection; writes candidate.xyz and accurate.xyz
 pmk perturb -i example.xyz -atom 0.2 -lattice 0.03 -n 100 -o example-perturb-atom-0.2-lattice-0.03.xyz
-pmk pca -i descriptor.out -o pca-descriptor.txt
+pmk pca -i descriptor.out -o pca-descriptor.txt -it train.xyz  # also split descriptors by Config_type
 pmk pca -i descriptor.out -o pca-descriptor.txt -fps 0.01 -it train.xyz
 pmk umap -i descriptor.out -o umap-descriptor.txt -fps 0.01 -it train.xyz
 pmk gpumd-thermo                              # current job, or recursively scan job folders
 pmk gpumd-thermo -t thermo.out -in run.in
+pmk gpumd-trjcat                            # stable ./<job>/traj.xyz files -> train.xyz
+pmk gpumd-trjcat -i traj.xyz -o train.xyz
 pmk trj-extract -it traj.xyz -in run.in -b 100 -e 200 -o traj-100ps-200ps.xyz
 
 pmk rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt
@@ -137,10 +140,14 @@ folder also keeps a `frame_N.xyz`, so `Config_type` survives for a later
 
 `nep-rmse -select`, PCA FPS, and UMAP FPS copy selected extended-XYZ frame blocks directly from the input trajectory. No parser rewrites energy, stress, forces, positions, precision, or extra metadata.
 
+When `pca` or `umap` receives `-it train.xyz`, it reads `Config_type` from every frame and writes one additional descriptor table per value, such as `pca-descriptor-P-3m1.txt` and `pca-descriptor-Pnma.txt`. With `-fps`, it also writes matching files such as `fps-0.01-pca-descriptor-P-3m1.txt` and `fps-0.01-train-P-3m1.xyz`. These files partition the single global FPS selection; FPS is not rerun independently for each `Config_type`. Frames without `Config_type` remain in the main outputs but do not receive a type-specific file.
+
 For folder conversion, `convert -if INPUT -of OUTPUT` writes `.xyz` by default. Set another target extension with `-oe`, for example `-oe cif` or `-oe vasp`. Single-file and trajectory modes infer the target format from `-o` and `-ot`.
 
 `gpumd-thermo` writes `temperature.txt`, `potential-energy.txt`, `pressure.txt`, `lattice-parameters.txt`, `volume.txt`, `lattice-angles.txt`, and a headless `thermo.png` in every detected GPUMD job folder. Its warning is a numerical reminder based on sustained drift or a level shift in the last `run` segment (or the last 80% when `run.in` has no `run` record); inspect the plot before deciding whether a trajectory is equilibrated.
 
+`gpumd-trjcat` recursively scans job subfolders for `traj.xyz`, `thermo.out`, and `run.in`. Jobs with missing, unreadable, or abnormal thermo data are skipped. Stable trajectories are merged in deterministic folder order. When `<job>/model.xyz` contains `Config_type`, that value is applied to every frame from the job while all other extended-XYZ bytes remain unchanged.
+
 Each command's full flag list is in `pmk <command> -help`.
 
 For long VASP batch submission, run `submit-vasp` with `nohup` and `&` if you
@@ -181,9 +188,13 @@ pymdkit/
 `-- src/pymdkit/
     |-- pymdkit_main.py         # dispatcher: discovers and runs commands
     `-- commands/               # one module per command
-        |-- _fileio.py          # shared -i/-o/-if/-of helper (not a command)
+        |-- _fileio.py          # shared -i/-o/-if/-of helper (not a command)
+        |-- _gpumd.py           # shared GPUMD run.in and thermo analysis
+        |-- _geometry.py        # shared minimum-image geometry helper
         |-- _vaspset.py         # shared VASP input-set helper (not a command)
-        |-- gpumd_group.py
+        |-- gpumd_group.py
+        |-- gpumd_thermo.py
+        |-- gpumd_trjcat.py
         |-- compute_ehull.py
         |-- compute_rmsd.py
         |-- ewald.py

{pymdkit-1.4.0 → pymdkit-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pymdkit"
-version = "1.4.0"
+version = "1.4.1"
 description = "A unified command-line toolkit for atomistic / MD structure workflows."
 readme = "README.md"
 requires-python = ">=3.9"

{pymdkit-1.4.0 → pymdkit-1.4.1}/src/pymdkit/__init__.py

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

pymdkit-1.4.1/src/pymdkit/commands/_extxyz.py

@@ -0,0 +1,85 @@
+"""Exact, byte-preserving helpers for extended-XYZ trajectories."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_CONFIG_TYPE_RE = re.compile(r'(?<!\S)Config_type=(?:"([^"]*)"|(\S+))')
+
+
+def read_blocks(path):
+    """Return ``(blocks, atom_counts)`` without parsing or reformatting data."""
+    path = Path(path)
+    lines = path.read_bytes().splitlines(keepends=True)
+    blocks = []
+    atom_counts = []
+    index = 0
+    while index < len(lines):
+        if not lines[index].strip():
+            index += 1
+            continue
+        try:
+            count = int(lines[index].strip())
+        except ValueError as exc:
+            raise ValueError(
+                f"{path}: expected an atom count at line {index + 1}"
+            ) from exc
+        stop = index + count + 2
+        if stop > len(lines):
+            raise ValueError(f"{path}: incomplete frame beginning at line {index + 1}")
+        blocks.append(b"".join(lines[index:stop]))
+        atom_counts.append(count)
+        index = stop
+    return blocks, atom_counts
+
+
+def write_blocks(path, blocks, indices):
+    """Write selected frames exactly as they appeared in the source file."""
+    Path(path).write_bytes(b"".join(blocks[int(index)] for index in indices))
+
+
+def _comment_line(block):
+    lines = block.splitlines(keepends=True)
+    if len(lines) < 2:
+        raise ValueError("incomplete XYZ frame: missing comment line")
+    raw = lines[1]
+    if raw.endswith(b"\r\n"):
+        body, newline = raw[:-2], b"\r\n"
+    elif raw.endswith(b"\n") or raw.endswith(b"\r"):
+        body, newline = raw[:-1], raw[-1:]
+    else:
+        body, newline = raw, b""
+    return lines, body.decode("utf-8"), newline
+
+
+def config_type_from_block(block):
+    """Return Config_type from one raw XYZ frame, if present."""
+    _, comment, _ = _comment_line(block)
+    match = _CONFIG_TYPE_RE.search(comment)
+    if not match:
+        return None
+    return match.group(1) if match.group(1) is not None else match.group(2)
+
+
+def read_config_type(path):
+    """Read Config_type from the first frame of an XYZ file, if present."""
+    blocks, _ = read_blocks(path)
+    return config_type_from_block(blocks[0]) if blocks else None
+
+
+def set_config_type(block, value):
+    """Set Config_type while preserving all other bytes in an XYZ frame."""
+    lines, comment, newline = _comment_line(block)
+    value = str(value)
+    if re.fullmatch(r'[^\s"=]+', value):
+        encoded_value = value
+    else:
+        encoded_value = '"' + value.replace('\\', '\\\\').replace('"', '\\"') + '"'
+    assignment = f"Config_type={encoded_value}"
+    if _CONFIG_TYPE_RE.search(comment):
+        comment = _CONFIG_TYPE_RE.sub(assignment, comment, count=1)
+    else:
+        comment += (" " if comment else "") + assignment
+    lines[1] = comment.encode("utf-8") + newline
+    return b"".join(lines)

{pymdkit-1.4.0 → pymdkit-1.4.1}/src/pymdkit/commands/_fileio.py

@@ -13,8 +13,15 @@ from pathlib import Path
 # File extensions we treat as structures when scanning an input folder.
 STRUCT_EXTS = {
     ".cif", ".vasp", ".poscar", ".xyz", ".extxyz", ".pdb", ".xsf",
-    ".cfg", ".gen", ".res", ".json", ".cssr", ".lmp", ".data",
+    ".cfg", ".gen", ".res", ".json", ".cssr", ".lmp", ".data", ".contcar",
 }
+STRUCT_NAMES = {"POSCAR", "CONTCAR"}
+
+
+def leading_index(name):
+    """Return a leading integer, placing nonnumeric names after numbered ones."""
+    match = re.match(r"^(\d+)", str(name))
+    return int(match.group(1)) if match else 10 ** 9
 
 
 def folder_sort_key(name):
@@ -54,8 +61,12 @@ def is_structure(path, exts=None):
     """True if *path* looks like a structure file (by extension / POSCAR name)."""
     exts = STRUCT_EXTS if exts is None else exts
     p = Path(path)
-    return p.is_file() and (p.suffix.lower() in exts
-                            or p.name.upper().startswith("POSCAR"))
+    upper_name = p.name.upper()
+    return p.is_file() and (
+        p.suffix.lower() in exts
+        or upper_name in STRUCT_NAMES
+        or upper_name.startswith("POSCAR")
+    )
 
 
 def structure_files(folder):
@@ -63,11 +74,7 @@ def structure_files(folder):
     folder = Path(folder)
     if not folder.is_dir():
         raise SystemExit(f"Error: input folder not found: {folder}")
-    files = sorted(
-        p for p in folder.iterdir()
-        if p.is_file() and (p.suffix.lower() in STRUCT_EXTS
-                            or p.name.upper().startswith("POSCAR"))
-    )
+    files = sorted(p for p in folder.iterdir() if is_structure(p))
     if not files:
         raise SystemExit(f"Error: no structure files found in {folder}")
     return files

pymdkit-1.4.1/src/pymdkit/commands/_geometry.py

@@ -0,0 +1,12 @@
+"""Small geometry helpers shared by structure commands."""
+
+from __future__ import annotations
+
+
+def fractional_distance(a, b):
+    """Return minimum-image Euclidean distance in fractional coordinates."""
+    import numpy as np
+
+    difference = np.asarray(a, dtype=float) - np.asarray(b, dtype=float)
+    difference -= np.round(difference)
+    return float(np.linalg.norm(difference))

pymdkit-1.4.1/src/pymdkit/commands/_gpumd.py

@@ -0,0 +1,172 @@
+"""Shared GPUMD input and thermo-analysis utilities."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class ThermoData:
+    time: np.ndarray
+    temperature: np.ndarray
+    potential: np.ndarray
+    pressure: np.ndarray
+    lengths: np.ndarray
+    angles: np.ndarray
+    volume: np.ndarray
+    equilibrium_start: int
+    warnings: tuple[str, ...]
+
+
+def parse_run_input(path):
+    time_step = 1.0
+    dump_interval = 10
+    runs = []
+    for raw in Path(path).read_text(encoding="utf-8").splitlines():
+        tokens = raw.split("#", 1)[0].split()
+        if not tokens:
+            continue
+        try:
+            if tokens[0] == "time_step" and len(tokens) >= 2:
+                time_step = float(tokens[1])
+            elif tokens[0] == "dump_thermo" and len(tokens) >= 2:
+                dump_interval = int(tokens[1])
+            elif tokens[0] == "run" and len(tokens) >= 2:
+                runs.append((int(tokens[1]), dump_interval, time_step))
+        except ValueError as exc:
+            raise ValueError(f"invalid {tokens[0]} setting in {path}: {raw}") from exc
+    return time_step, dump_interval, runs
+
+
+def time_axis(length, time_step, dump_interval, runs):
+    expected = sum(steps // interval for steps, interval, _ in runs)
+    if runs and expected == length:
+        values = []
+        elapsed = 0.0
+        for steps, interval, step_fs in runs:
+            count = steps // interval
+            increment = step_fs * interval / 1000.0
+            values.extend(elapsed + np.arange(count) * increment)
+            elapsed += steps * step_fs / 1000.0
+        return np.asarray(values, dtype=float)
+    increment = time_step * dump_interval / 1000.0
+    return np.arange(length, dtype=float) * increment
+
+
+def equilibrium_start(length, runs):
+    if not runs:
+        return int(length * 0.2)
+    points = runs[-1][0] // runs[-1][1]
+    return max(0, length - points)
+
+
+def cell_quantities(data):
+    if data.shape[1] == 12:
+        lengths = data[:, 9:12]
+        angles = np.full((len(data), 3), 90.0)
+        return lengths, angles, np.prod(lengths, axis=1)
+    if data.shape[1] != 18:
+        raise ValueError(
+            f"thermo.out has {data.shape[1]} columns; expected 12 or 18"
+        )
+
+    vectors = data[:, 9:18].reshape(-1, 3, 3)
+    lengths = np.linalg.norm(vectors, axis=2)
+
+    def angle(first, second):
+        denominator = np.linalg.norm(first, axis=1) * np.linalg.norm(second, axis=1)
+        cosine = np.divide(
+            np.einsum("ij,ij->i", first, second), denominator,
+            out=np.zeros(len(first)), where=denominator != 0,
+        )
+        return np.degrees(np.arccos(np.clip(cosine, -1.0, 1.0)))
+
+    angles = np.column_stack([
+        angle(vectors[:, 1], vectors[:, 2]),
+        angle(vectors[:, 2], vectors[:, 0]),
+        angle(vectors[:, 0], vectors[:, 1]),
+    ])
+    return lengths, angles, np.abs(np.linalg.det(vectors))
+
+
+def abnormal_reason(values):
+    values = np.asarray(values, dtype=float)
+    values = values[np.isfinite(values)]
+    if len(values) < 20 or np.ptp(values) == 0:
+        return None
+
+    count = max(3, len(values) // 5)
+    first = float(np.mean(values[:count]))
+    last = float(np.mean(values[-count:]))
+    spread = float(np.std(values))
+    scale = max(abs(float(np.median(values))), 1.0)
+    threshold = max(0.5 * spread, 0.005 * scale)
+
+    shift = last - first
+    if abs(shift) > threshold:
+        return f"level shift {shift:+.5g}"
+
+    x = np.linspace(-0.5, 0.5, len(values))
+    slope = float(np.polyfit(x, values, 1)[0])
+    if abs(slope) > threshold:
+        return f"sustained drift {slope:+.5g} over the equilibrium segment"
+    return None
+
+
+def find_abnormal(series, start):
+    component_names = {
+        "pressure": ("x", "y", "z"),
+        "lattice-parameter": ("a", "b", "c"),
+        "lattice-angle": ("alpha", "beta", "gamma"),
+    }
+    warnings = []
+    for name, values in series.items():
+        array = np.asarray(values)
+        if array.ndim == 1:
+            array = array[:, None]
+        labels = component_names.get(name, tuple(str(i) for i in range(array.shape[1])))
+        if array.shape[1] == 1:
+            labels = (name,)
+        for label, column in zip(labels, array.T):
+            reason = abnormal_reason(column[start:])
+            if reason:
+                prefix = name if label == name else f"{name}-{label}"
+                warnings.append(f"{prefix}: {reason}")
+    return tuple(warnings)
+
+
+def load_thermo(thermo_path, run_path):
+    thermo_path = Path(thermo_path)
+    data = np.loadtxt(thermo_path, ndmin=2)
+    if data.shape[1] not in (12, 18):
+        raise ValueError(f"{thermo_path} must contain 12 or 18 columns")
+
+    time_step, dump_interval, runs = parse_run_input(run_path)
+    time = time_axis(len(data), time_step, dump_interval, runs)
+    temperature = data[:, 0]
+    potential = data[:, 2]
+    pressure = data[:, 3:6]
+    lengths, angles, volume = cell_quantities(data)
+    start = equilibrium_start(len(data), runs)
+    warnings = find_abnormal({
+        "temperature": temperature,
+        "potential-energy": potential,
+        "pressure": pressure,
+        "lattice-parameter": lengths,
+        "volume": volume,
+        "lattice-angle": angles,
+    }, start)
+    return ThermoData(
+        time=time,
+        temperature=temperature,
+        potential=potential,
+        pressure=pressure,
+        lengths=lengths,
+        angles=angles,
+        volume=volume,
+        equilibrium_start=start,
+        warnings=warnings,
+    )

pymdkit-1.4.1/src/pymdkit/commands/_reduction.py

@@ -0,0 +1,165 @@
+"""Shared descriptor reduction and farthest-point sampling helpers."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import numpy as np
+
+try:
+    from ._extxyz import config_type_from_block, read_blocks, write_blocks
+except ImportError:
+    from _extxyz import config_type_from_block, read_blocks, write_blocks
+
+
+def load_descriptors(path):
+    data = np.loadtxt(path, ndmin=2)
+    if data.shape[0] == 0 or data.shape[1] == 0:
+        raise ValueError(f"descriptor file is empty: {path}")
+    if not np.all(np.isfinite(data)):
+        raise ValueError(f"descriptor file contains non-finite values: {path}")
+    return data
+
+
+def pca_2d(data):
+    centered = data - np.mean(data, axis=0, keepdims=True)
+    if len(data) == 1:
+        return np.zeros((1, 2)), np.array([0.0, 0.0])
+    _, singular, vh = np.linalg.svd(centered, full_matrices=False)
+    dimensions = min(2, vh.shape[0])
+    reduced = centered @ vh[:dimensions].T
+    if dimensions < 2:
+        reduced = np.column_stack([reduced, np.zeros(len(data))])
+    variance = singular ** 2
+    ratio = variance / variance.sum() if variance.sum() else np.zeros_like(variance)
+    explained = np.zeros(2)
+    explained[:min(2, len(ratio))] = ratio[:2]
+    return reduced, explained
+
+
+def umap_2d(data):
+    if len(data) < 3:
+        return pca_2d(data)[0]
+    import umap
+
+    neighbors = min(15, len(data) - 1)
+    reducer = umap.UMAP(
+        n_components=2,
+        n_neighbors=neighbors,
+        random_state=42,
+        transform_seed=42,
+    )
+    return reducer.fit_transform(data)
+
+
+def farthest_point_sampling(points, min_distance):
+    if min_distance < 0:
+        raise ValueError("-fps must be non-negative")
+    selected = [0]
+    min_distances = np.linalg.norm(points - points[0], axis=1)
+    min_distances[0] = -np.inf
+    while True:
+        index = int(np.argmax(min_distances))
+        if min_distances[index] < min_distance:
+            break
+        selected.append(index)
+        distances = np.linalg.norm(points - points[index], axis=1)
+        min_distances = np.minimum(min_distances, distances)
+        min_distances[selected] = -np.inf
+    return np.asarray(selected, dtype=int)
+
+
+def fps_label(value):
+    return format(float(value), "g")
+
+
+def _filename_label(config_type):
+    label = re.sub(r"[^A-Za-z0-9_.+-]+", "-", str(config_type)).strip("-.")
+    return label or "unknown"
+
+
+def _labeled_path(path, config_type):
+    path = Path(path)
+    return path.with_name(f"{path.stem}-{_filename_label(config_type)}{path.suffix}")
+
+
+def _config_groups(blocks):
+    groups = {}
+    labels = {}
+    for index, block in enumerate(blocks):
+        config_type = config_type_from_block(block)
+        if config_type is None:
+            continue
+        label = _filename_label(config_type)
+        if label in labels and labels[label] != config_type:
+            raise ValueError(
+                f"Config_type values {labels[label]!r} and {config_type!r} "
+                f"map to the same filename label {label!r}"
+            )
+        labels[label] = config_type
+        groups.setdefault(config_type, []).append(index)
+    return {name: np.asarray(indices, dtype=int) for name, indices in groups.items()}
+
+
+def _write_config_outputs(descriptor_path, reduced, groups, selected=None,
+                          trajectory_path=None, blocks=None):
+    for config_type, group_indices in groups.items():
+        indices = group_indices
+        if selected is not None:
+            indices = np.intersect1d(selected, group_indices, assume_unique=True)
+        config_descriptor = _labeled_path(descriptor_path, config_type)
+        np.savetxt(config_descriptor, reduced[indices], fmt="%.8f")
+        outputs = [str(config_descriptor)]
+        if trajectory_path is not None:
+            config_trajectory = _labeled_path(trajectory_path, config_type)
+            write_blocks(config_trajectory, blocks, indices)
+            outputs.append(str(config_trajectory))
+        print(f"Config_type={config_type}: {len(indices)} row(s) -> "
+              + " and ".join(outputs))
+
+
+def write_reduction(output, reduced, fps=None, trajectory=None):
+    if fps is not None and trajectory is None:
+        raise ValueError("-it is required when -fps is used")
+
+    output = Path(output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    np.savetxt(output, reduced, fmt="%.8f")
+    print(f"Wrote {len(reduced)} reduced descriptor(s) to {output}")
+
+    blocks = None
+    groups = {}
+    if trajectory is not None:
+        blocks, _ = read_blocks(trajectory)
+        if len(blocks) != len(reduced):
+            raise ValueError(
+                f"{trajectory} has {len(blocks)} frame(s), but the descriptor file "
+                f"has {len(reduced)} row(s)"
+            )
+        groups = _config_groups(blocks)
+        _write_config_outputs(output, reduced, groups)
+        untyped = len(blocks) - sum(len(indices) for indices in groups.values())
+        if untyped:
+            print(f"{untyped} frame(s) have no Config_type and were not split by type.")
+
+    if fps is None:
+        return
+
+    selected = np.sort(farthest_point_sampling(reduced, fps))
+    label = fps_label(fps)
+    descriptor_output = output.with_name(f"fps-{label}-{output.name}")
+    trajectory = Path(trajectory)
+    trajectory_output = trajectory.with_name(f"fps-{label}-{trajectory.name}")
+    np.savetxt(descriptor_output, reduced[selected], fmt="%.8f")
+    write_blocks(trajectory_output, blocks, selected)
+    print(f"FPS distance {label}: selected {len(selected)} of {len(reduced)} structure(s)")
+    print(f"Wrote {descriptor_output} and {trajectory_output}")
+    _write_config_outputs(
+        descriptor_output,
+        reduced,
+        groups,
+        selected=selected,
+        trajectory_path=trajectory_output,
+        blocks=blocks,
+    )

{pymdkit-1.4.0 → pymdkit-1.4.1}/src/pymdkit/commands/compute_ehull.py

@@ -4,15 +4,15 @@ from __future__ import annotations
 
 import argparse
 import math
-import re
 import warnings
 from collections import defaultdict
 from pathlib import Path
 
 
 try:
-    from . import _vasp_output
+    from . import _fileio, _vasp_output
 except ImportError:  # running as a standalone script
+    import _fileio
     import _vasp_output
 
 warnings.filterwarnings("ignore", category=UserWarning)
@@ -22,10 +22,6 @@ HELP = "Compute E_hull for every VASP job folder."
 REPORT_FILE = "ehull.txt"
 
 
-def folder_index(name: str) -> int:
-    m = re.match(r"^(\d+)", name)
-    return int(m.group(1)) if m else 10 ** 9
-
 
 def chemsys_label(entry) -> str:
     def keyfn(el):
@@ -98,7 +94,7 @@ def collect_entries(root):
     root = Path(root)
     folders = sorted(
         (f for f in root.iterdir() if f.is_dir() and _vasp_output.has_vasp_output(f)),
-        key=lambda f: folder_index(f.name),
+        key=lambda f: _fileio.leading_index(f.name),
     )
     out = []
     for folder in folders:
@@ -208,7 +204,7 @@ def run(args):
                     "e_hull": e_hull,
                 })
 
-    results.sort(key=lambda r: folder_index(r["folder"]))
+    results.sort(key=lambda r: _fileio.leading_index(r["folder"]))
     write_report(results, root, REPORT_FILE, reference)
     print(f"\nWrote {REPORT_FILE} ({len(results)} structures).")
     return 0