pymdkit 1.4.1__tar.gz → 1.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.4.1
+Version: 1.4.2
 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
@@ -63,13 +63,14 @@ directory for job sub-folders automatically.
 
 | Command | What it does |
 |---|---|
+| `add-config-type` | Add Config_type to one XYZ structure or every trajectory frame |
 | `gpumd-group` | Tag atoms with a GPUMD group index by element order |
 | `ewald` | Compute CIF electrostatic energy with pymatgen EwaldSummation |
 | `ehull` | Auto-detect VASP job folders and compute E_hull vs Materials Project |
 | `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 |
+| `gpumd-trjcat` | Merge stable GPUMD trajectories and extract abnormal time regions |
 | `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 |
@@ -90,6 +91,8 @@ directory for job sub-folders automatically.
 ## Examples
 
 ```bash
+pmk add-config-type -i single-structure.xyz -n P-3m1
+pmk add-config-type -it trajectory.xyz -n P-3m1
 pmk gpumd-group -i opted.cif -elements Li Y Cl -o model.xyz
 pmk gpumd-group -if cifs/ -elements Li Y Cl -of cifs-grouped/   # whole folder
 pmk gpumd-group -elements Li Y Cl                              # scan subfolders, tag each model.xyz in place
@@ -131,8 +134,8 @@ 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 gpumd-trjcat                            # stable frames -> train.xyz; abnormal regions -> abnormal.xyz
+pmk gpumd-trjcat -i traj.xyz -o train.xyz -ao abnormal.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
@@ -164,15 +167,17 @@ multi-structure trajectory and writes one job sub-folder per frame
 folder also keeps a `frame_N.xyz`, so `Config_type` survives for a later
 `vasp2xyz`.
 
+`add-config-type` updates its input atomically in place. With `-i`, the file must contain exactly one XYZ structure; use `-it` for a trajectory. Existing `Config_type` values are replaced, missing values are added, and all other extended-XYZ bytes remain unchanged.
+
 `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-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. Potential energy is the primary equilibrium signal: sustained potential-energy shifts, drifts, or localized departures define an abnormal job or time region. Lattice parameters, volume, temperature, pressure, and angles remain supporting diagnostics. The analysis uses the last `run` segment, or the last 80% when `run.in` has no `run` record; inspect the plot before making a final scientific judgment.
 
-`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.
+`gpumd-trjcat` recursively scans job subfolders for `traj.xyz`, `thermo.out`, and `run.in`. Stable trajectories are merged in deterministic folder order into `train.xyz` (or `-o`). For an abnormal job, only frames whose times fall in potential-energy abnormal regions are written to `abnormal.xyz` (or `-ao`); frame times are obtained from `time_step` and `dump_xyz` in that job's `run.in`. Missing, unreadable, or unmappable jobs are skipped. When `<job>/model.xyz` contains `Config_type`, that value is applied to every exported frame while all other extended-XYZ bytes remain unchanged.
 
 Each command's full flag list is in `pmk <command> -help`.
 
@@ -227,6 +232,7 @@ pymdkit/
         |-- vasp_fe.py
         |-- perturb.py
         |-- nep_rmse.py
+        |-- add_config_type.py
         |-- chemsys_entry.py
         |-- submit_vasp.py
         |-- convert.py

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

@@ -37,13 +37,14 @@ directory for job sub-folders automatically.
 
 | Command | What it does |
 |---|---|
+| `add-config-type` | Add Config_type to one XYZ structure or every trajectory frame |
 | `gpumd-group` | Tag atoms with a GPUMD group index by element order |
 | `ewald` | Compute CIF electrostatic energy with pymatgen EwaldSummation |
 | `ehull` | Auto-detect VASP job folders and compute E_hull vs Materials Project |
 | `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 |
+| `gpumd-trjcat` | Merge stable GPUMD trajectories and extract abnormal time regions |
 | `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 |
@@ -64,6 +65,8 @@ directory for job sub-folders automatically.
 ## Examples
 
 ```bash
+pmk add-config-type -i single-structure.xyz -n P-3m1
+pmk add-config-type -it trajectory.xyz -n P-3m1
 pmk gpumd-group -i opted.cif -elements Li Y Cl -o model.xyz
 pmk gpumd-group -if cifs/ -elements Li Y Cl -of cifs-grouped/   # whole folder
 pmk gpumd-group -elements Li Y Cl                              # scan subfolders, tag each model.xyz in place
@@ -105,8 +108,8 @@ 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 gpumd-trjcat                            # stable frames -> train.xyz; abnormal regions -> abnormal.xyz
+pmk gpumd-trjcat -i traj.xyz -o train.xyz -ao abnormal.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
@@ -138,15 +141,17 @@ multi-structure trajectory and writes one job sub-folder per frame
 folder also keeps a `frame_N.xyz`, so `Config_type` survives for a later
 `vasp2xyz`.
 
+`add-config-type` updates its input atomically in place. With `-i`, the file must contain exactly one XYZ structure; use `-it` for a trajectory. Existing `Config_type` values are replaced, missing values are added, and all other extended-XYZ bytes remain unchanged.
+
 `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-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. Potential energy is the primary equilibrium signal: sustained potential-energy shifts, drifts, or localized departures define an abnormal job or time region. Lattice parameters, volume, temperature, pressure, and angles remain supporting diagnostics. The analysis uses the last `run` segment, or the last 80% when `run.in` has no `run` record; inspect the plot before making a final scientific judgment.
 
-`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.
+`gpumd-trjcat` recursively scans job subfolders for `traj.xyz`, `thermo.out`, and `run.in`. Stable trajectories are merged in deterministic folder order into `train.xyz` (or `-o`). For an abnormal job, only frames whose times fall in potential-energy abnormal regions are written to `abnormal.xyz` (or `-ao`); frame times are obtained from `time_step` and `dump_xyz` in that job's `run.in`. Missing, unreadable, or unmappable jobs are skipped. When `<job>/model.xyz` contains `Config_type`, that value is applied to every exported frame while all other extended-XYZ bytes remain unchanged.
 
 Each command's full flag list is in `pmk <command> -help`.
 
@@ -201,6 +206,7 @@ pymdkit/
         |-- vasp_fe.py
         |-- perturb.py
         |-- nep_rmse.py
+        |-- add_config_type.py
         |-- chemsys_entry.py
         |-- submit_vasp.py
         |-- convert.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pymdkit"
-version = "1.4.1"
+version = "1.4.2"
 description = "A unified command-line toolkit for atomistic / MD structure workflows."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -20,7 +20,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Physics",
 ]
 
-# All dependencies are installed up front so a plain ppip install pymdkitp
+# All dependencies are installed up front so a plain `pip install pymdkit`
 # gives a fully working CLI. Heavy libraries are still imported lazily inside
 # individual commands, so the dispatcher and pmk -help stay fast.
 dependencies = [
@@ -36,7 +36,7 @@ dependencies = [
 ]
 
 [project.scripts]
-# The distribution remains pymdkit; the concise public executable is ppmkp.
+# The distribution remains pymdkit; the concise public executable is `pmk`.
 pmk = "pymdkit.pymdkit_main:main"
 
 [tool.setuptools.packages.find]

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

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

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

@@ -0,0 +1,348 @@
+"""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
+    abnormal_mask: np.ndarray
+    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 trajectory_interval(run_input, trajectory):
+    """Return the GPUMD XYZ dump timing as (time_step, steps, ps)."""
+    time_step = None
+    dump_intervals = []
+    trajectory_name = Path(trajectory).name
+    for raw in Path(run_input).read_text(encoding="utf-8").splitlines():
+        tokens = raw.split("#", 1)[0].split()
+        if not tokens:
+            continue
+        if tokens[0] == "time_step" and len(tokens) >= 2:
+            time_step = float(tokens[1])
+        elif tokens[0] == "dump_xyz" and len(tokens) >= 2:
+            numeric = []
+            for token in tokens[1:-1] if len(tokens) > 2 else tokens[1:]:
+                try:
+                    value = int(token)
+                except ValueError:
+                    continue
+                if value > 0:
+                    numeric.append(value)
+            if numeric:
+                dump_intervals.append((tokens[-1] == trajectory_name, numeric[-1]))
+    if time_step is None:
+        raise ValueError(f"no time_step setting found in {run_input}")
+    matching = [value for matches, value in dump_intervals if matches]
+    if matching:
+        dump_interval = matching[-1]
+    elif dump_intervals:
+        dump_interval = dump_intervals[-1][1]
+    else:
+        raise ValueError(f"no usable dump_xyz interval found in {run_input}")
+    return time_step, dump_interval, time_step * dump_interval / 1000.0
+
+
+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 _robust_spread(values):
+    values = np.asarray(values, dtype=float)
+    center = float(np.median(values))
+    spread = 1.4826 * float(np.median(np.abs(values - center)))
+    if spread == 0:
+        spread = float(np.std(values))
+    return center, spread
+
+
+def _clean_mask(mask):
+    mask = np.asarray(mask, dtype=bool).copy()
+    size = len(mask)
+    if not mask.any():
+        return mask
+
+    max_gap = max(1, size // 200)
+    index = 0
+    while index < size:
+        if mask[index]:
+            index += 1
+            continue
+        end = index
+        while end < size and not mask[end]:
+            end += 1
+        if index > 0 and end < size and end - index <= max_gap:
+            mask[index:end] = True
+        index = end
+
+    minimum = max(3, size // 100)
+    index = 0
+    while index < size:
+        if not mask[index]:
+            index += 1
+            continue
+        end = index
+        while end < size and mask[end]:
+            end += 1
+        if end - index < minimum:
+            mask[index:end] = False
+        index = end
+    return mask
+
+
+def potential_abnormal_mask(values):
+    """Locate sustained potential-energy transitions or departures."""
+    values = np.asarray(values, dtype=float)
+    size = len(values)
+    if size < 20 or not np.all(np.isfinite(values)):
+        return np.zeros(size, dtype=bool)
+
+    edge_count = max(5, size // 10)
+    left_center, left_spread = _robust_spread(values[:edge_count])
+    right_center, right_spread = _robust_spread(values[-edge_count:])
+    difference = abs(right_center - left_center)
+
+    window = max(5, size // 50)
+    if window % 2 == 0:
+        window += 1
+    radius = window // 2
+    smooth = np.asarray([
+        np.median(values[max(0, i - radius):min(size, i + radius + 1)])
+        for i in range(size)
+    ])
+
+    mean_threshold = max(
+        6.0 * np.hypot(left_spread, right_spread) / np.sqrt(edge_count),
+        1e-6 * max(abs(left_center), abs(right_center), 1.0),
+    )
+    if difference > mean_threshold:
+        # Both edge plateaus are valid equilibrium levels. Mark only samples
+        # between them, not either stable plateau.
+        plateau_tolerance = max(
+            4.0 * max(left_spread, right_spread) / np.sqrt(window),
+            0.02 * difference,
+            1e-12,
+        )
+        distance = np.minimum(
+            np.abs(smooth - left_center), np.abs(smooth - right_center)
+        )
+        transition = _clean_mask(distance > plateau_tolerance)
+        if transition.any():
+            return transition
+
+        # An abrupt jump may contain no intermediate values. In that case,
+        # retain a narrow window around the change rather than one plateau.
+        score = np.zeros(size)
+        for index in range(window, size - window):
+            score[index] = abs(
+                np.mean(smooth[index:index + window])
+                - np.mean(smooth[index - window:index])
+            )
+        threshold = max(
+            0.1 * difference,
+            4.0 * max(left_spread, right_spread) / np.sqrt(window),
+        )
+        return _clean_mask(score > threshold)
+
+    baseline = np.concatenate((values[:edge_count], values[-edge_count:]))
+    center, spread = _robust_spread(baseline)
+    threshold = max(6.0 * spread, 1e-6 * max(abs(center), 1.0), 1e-12)
+    return _clean_mask(np.abs(smooth - center) > threshold)
+
+
+def mask_intervals(time, mask):
+    """Return inclusive physical-time intervals for contiguous true mask regions."""
+    time = np.asarray(time, dtype=float)
+    mask = np.asarray(mask, dtype=bool)
+    intervals = []
+    index = 0
+    while index < len(mask):
+        if not mask[index]:
+            index += 1
+            continue
+        end = index
+        while end + 1 < len(mask) and mask[end + 1]:
+            end += 1
+        intervals.append((float(time[index]), float(time[end])))
+        index = end + 1
+    return intervals
+
+
+def _format_intervals(intervals):
+    return ", ".join(f"{begin:g}-{end:g} ps" for begin, end in intervals)
+
+
+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)
+
+    abnormal_mask = np.zeros(len(data), dtype=bool)
+    abnormal_mask[start:] = potential_abnormal_mask(potential[start:])
+    intervals = mask_intervals(time, abnormal_mask)
+    warnings = []
+    if intervals:
+        warnings.append(
+            "potential-energy: localized abnormal region(s) at "
+            + _format_intervals(intervals)
+        )
+    else:
+        potential_reason = abnormal_reason(potential[start:])
+        if potential_reason:
+            warnings.append(f"potential-energy: {potential_reason}")
+            abnormal_mask[start:] = True
+
+    warnings.extend(find_abnormal({
+        "temperature": temperature,
+        "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,
+        abnormal_mask=abnormal_mask,
+        warnings=tuple(warnings),
+    )

pymdkit-1.4.2/src/pymdkit/commands/add_config_type.py

@@ -0,0 +1,64 @@
+"""Add or replace Config_type in one structure or every trajectory frame."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+try:
+    from ._extxyz import read_blocks, set_config_type
+except ImportError:
+    from _extxyz import read_blocks, set_config_type
+
+COMMAND = "add-config-type"
+HELP = "Add Config_type to a single XYZ structure or every trajectory frame."
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    inputs = parser.add_mutually_exclusive_group(required=True)
+    inputs.add_argument("-i", "-input", dest="input",
+                        help="Single-structure XYZ file to update in place.")
+    inputs.add_argument("-it", "-input-trajectory", dest="input_trajectory",
+                        help="XYZ trajectory to update in place.")
+    parser.add_argument("-n", "-name", dest="name", required=True,
+                        help="Config_type value, for example P-3m1.")
+
+
+def update_file(path, config_type, single_structure=False):
+    path = Path(path)
+    if not path.is_file():
+        raise ValueError(f"input file not found: {path}")
+    blocks, _ = read_blocks(path)
+    if not blocks:
+        raise ValueError(f"input contains no XYZ structures: {path}")
+    if single_structure and len(blocks) != 1:
+        raise ValueError(
+            f"-i requires exactly one structure, but {path} has {len(blocks)} frames; "
+            "use -it for a trajectory"
+        )
+
+    updated = [set_config_type(block, config_type) for block in blocks]
+    temporary = path.with_name(f".{path.name}.pmk-tmp")
+    try:
+        temporary.write_bytes(b"".join(updated))
+        temporary.replace(path)
+    except Exception:
+        temporary.unlink(missing_ok=True)
+        raise
+    return len(updated)
+
+
+def run(args) -> int:
+    path = args.input if args.input else args.input_trajectory
+    try:
+        count = update_file(path, args.name, single_structure=bool(args.input))
+    except (OSError, ValueError) as exc:
+        raise SystemExit(f"Error: {exc}") from exc
+    print(f"Set Config_type={args.name} in {count} structure(s): {path}")
+    return 0
+
+
+if __name__ == "__main__":
+    _parser = argparse.ArgumentParser(description=__doc__)
+    add_arguments(_parser)
+    raise SystemExit(run(_parser.parse_args()))