pymdkit 1.4.2__tar.gz → 1.4.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.4.2
+Version: 1.4.4
 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
@@ -73,6 +73,7 @@ directory for job sub-folders automatically.
 | `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 |
+| `trj-sparse` | Deterministically retain a requested fraction of XYZ trajectory frames |
 | `umap` | Reduce descriptor data to two dimensions with UMAP; optional FPS sampling |
 | `msd` | Diffusivity & conductivity from GPUMD MSD jobs (auto-scans `<structure>/<temp>/`) |
 | `nep-rmse` | Compute NEP energy/force/stress RMSE with terminal plots and optional candidate selection |
@@ -137,6 +138,7 @@ pmk gpumd-thermo -t thermo.out -in run.in
 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 trj-sparse -it example.xyz -r 0.5 -o sparse-example.xyz
 
 pmk rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt
 pmk rmsd vasp-opted/                            # all pairs in a folder -> rmsd.txt
@@ -175,9 +177,13 @@ When `pca` or `umap` receives `-it train.xyz`, it reads `Config_type` from every
 
 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. 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-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. Detection requires a persistent change with a meaningful magnitude relative to the robust natural energy fluctuations, so ordinary correlated thermal noise and isolated spikes are not classified as abnormal. When multiple lattice or volume measures independently show a transition, a more sensitive noise-relative potential-energy test is enabled; this avoids a fixed eV or percentage-of-total-energy threshold that would depend on system size. Lattice parameters, volume, temperature, pressure, and angles remain supporting diagnostics. Thermo plots use Arial when available, opaque legends, correct Å units, and shaded abnormal regions on potential energy, lattice parameters, and volume. Potential energy and volume are divided by 1000 and labeled ×10³ only when their absolute plotted values reach 1000. 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`. 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.
+The thermo parser follows the [official GPUMD thermo.out format](https://gpumd.org/gpumd/output_files/thermo_out.html): 18 columns are required, `pressure.txt` exports `Pxx Pyy Pzz Pyz Pxz Pxy`, box vectors are interpreted as a full 3×3 matrix, `time_step` propagates between runs, and `dump_thermo` does not.
+
+`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, frames from the structurally corroborated potential-energy region are written to `abnormal.xyz` (or `-ao`); if no energy region can be resolved, the dominant structural transition is used as a fallback so an abnormal job cannot produce an empty abnormal output. 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.
+
+`trj-sparse` keeps `max(1, floor(frame_count × ratio))` frames without rewriting their extended-XYZ content. Selection is deterministic and starts with frame zero; for 100 frames and `-r 0.5`, it writes source indices `0, 2, ..., 98`.
 
 Each command's full flag list is in `pmk <command> -help`.
 

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

@@ -46,7 +46,8 @@ directory for job sub-folders automatically.
 | `gpumd-thermo` | Export and plot GPUMD thermo data and detect sustained equilibrium changes |
 | `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 |
+| `trj-extract` | Extract a GPUMD XYZ trajectory by time range |
+| `trj-sparse` | Deterministically retain a requested fraction of XYZ trajectory frames |
 | `umap` | Reduce descriptor data to two dimensions with UMAP; optional FPS sampling |
 | `msd` | Diffusivity & conductivity from GPUMD MSD jobs (auto-scans `<structure>/<temp>/`) |
 | `nep-rmse` | Compute NEP energy/force/stress RMSE with terminal plots and optional candidate selection |
@@ -110,7 +111,8 @@ pmk gpumd-thermo                              # current job, or recursively scan
 pmk gpumd-thermo -t thermo.out -in run.in
 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 trj-extract -it traj.xyz -in run.in -b 100 -e 200 -o traj-100ps-200ps.xyz
+pmk trj-sparse -it example.xyz -r 0.5 -o sparse-example.xyz
 
 pmk rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt
 pmk rmsd vasp-opted/                            # all pairs in a folder -> rmsd.txt
@@ -149,10 +151,14 @@ When `pca` or `umap` receives `-it train.xyz`, it reads `Config_type` from every
 
 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. 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-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. Detection requires a persistent change with a meaningful magnitude relative to the robust natural energy fluctuations, so ordinary correlated thermal noise and isolated spikes are not classified as abnormal. When multiple lattice or volume measures independently show a transition, a more sensitive noise-relative potential-energy test is enabled; this avoids a fixed eV or percentage-of-total-energy threshold that would depend on system size. Lattice parameters, volume, temperature, pressure, and angles remain supporting diagnostics. Thermo plots use Arial when available, opaque legends, correct Å units, and shaded abnormal regions on potential energy, lattice parameters, and volume. Potential energy and volume are divided by 1000 and labeled ×10³ only when their absolute plotted values reach 1000. 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`. 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.
+The thermo parser follows the [official GPUMD thermo.out format](https://gpumd.org/gpumd/output_files/thermo_out.html): 18 columns are required, `pressure.txt` exports `Pxx Pyy Pzz Pyz Pxz Pxy`, box vectors are interpreted as a full 3×3 matrix, `time_step` propagates between runs, and `dump_thermo` does not.
+
+`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, frames from the structurally corroborated potential-energy region are written to `abnormal.xyz` (or `-ao`); if no energy region can be resolved, the dominant structural transition is used as a fallback so an abnormal job cannot produce an empty abnormal output. 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.
 
+`trj-sparse` keeps `max(1, floor(frame_count × ratio))` frames without rewriting their extended-XYZ content. Selection is deterministic and starts with frame zero; for 100 frames and `-r 0.5`, it writes source indices `0, 2, ..., 98`.
+
 Each command's full flag list is in `pmk <command> -help`.
 
 For long VASP batch submission, run `submit-vasp` with `nohup` and `&` if you

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

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

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

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

{pymdkit-1.4.2 → pymdkit-1.4.4}/src/pymdkit/commands/_gpumd.py

@@ -24,7 +24,8 @@ class ThermoData:
 
 def parse_run_input(path):
     time_step = 1.0
-    dump_interval = 10
+    active_dump = None
+    last_dump = None
     runs = []
     for raw in Path(path).read_text(encoding="utf-8").splitlines():
         tokens = raw.split("#", 1)[0].split()
@@ -34,13 +35,16 @@ def parse_run_input(path):
             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])
+                active_dump = int(tokens[1])
+                if active_dump <= 0:
+                    raise ValueError("dump_thermo interval must be positive")
+                last_dump = active_dump
             elif tokens[0] == "run" and len(tokens) >= 2:
-                runs.append((int(tokens[1]), dump_interval, time_step))
+                runs.append((int(tokens[1]), active_dump, time_step))
+                active_dump = None
         except ValueError as exc:
             raise ValueError(f"invalid {tokens[0]} setting in {path}: {raw}") from exc
-    return time_step, dump_interval, runs
-
+    return time_step, last_dump, runs
 
 def trajectory_interval(run_input, trajectory):
     """Return the GPUMD XYZ dump timing as (time_step, steps, ps)."""
@@ -77,35 +81,38 @@ def trajectory_interval(run_input, trajectory):
 
 
 def time_axis(length, time_step, dump_interval, runs):
-    expected = sum(steps // interval for steps, interval, _ in runs)
+    expected = sum(
+        steps // interval
+        for steps, interval, _ in runs
+        if interval is not None
+    )
     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)
+            if interval is not None:
+                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)
+    if dump_interval is None:
+        raise ValueError("no dump_thermo setting found in run.in")
     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)
-
+    for steps, interval, _ in reversed(runs):
+        if interval is not None:
+            points = steps // interval
+            return max(0, length - points)
+    return int(length * 0.2)
 
 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"
+            f"thermo.out has {data.shape[1]} columns; expected the official 18-column format"
         )
 
     vectors = data[:, 9:18].reshape(-1, 3, 3)
@@ -194,8 +201,48 @@ def _clean_mask(mask):
     return mask
 
 
-def potential_abnormal_mask(values):
-    """Locate sustained potential-energy transitions or departures."""
+def _bridge_mask(mask, max_gap):
+    mask = np.asarray(mask, dtype=bool).copy()
+    index = 0
+    while index < len(mask):
+        if mask[index]:
+            index += 1
+            continue
+        end = index
+        while end < len(mask) and not mask[end]:
+            end += 1
+        if index > 0 and end < len(mask) and end - index <= max_gap:
+            mask[index:end] = True
+        index = end
+    return mask
+
+
+def _keep_major_regions(mask):
+    mask = np.asarray(mask, dtype=bool)
+    regions = []
+    index = 0
+    while index < len(mask):
+        if not mask[index]:
+            index += 1
+            continue
+        end = index
+        while end < len(mask) and mask[end]:
+            end += 1
+        regions.append((index, end))
+        index = end
+    if not regions:
+        return np.zeros(len(mask), dtype=bool)
+
+    longest = max(end - begin for begin, end in regions)
+    minimum = max(3, len(mask) // 50, longest // 4)
+    result = np.zeros(len(mask), dtype=bool)
+    for begin, end in regions:
+        if end - begin >= minimum:
+            result[begin:end] = True
+    return result
+
+
+def _persistent_change_mask(values, corroborated=False, bridge=True):
     values = np.asarray(values, dtype=float)
     size = len(values)
     if size < 20 or not np.all(np.isfinite(values)):
@@ -204,55 +251,69 @@ def potential_abnormal_mask(values):
     edge_count = max(5, size // 10)
     left_center, left_spread = _robust_spread(values[:edge_count])
     right_center, right_spread = _robust_spread(values[-edge_count:])
+    noise = max(left_spread, right_spread, 1e-12)
     difference = abs(right_center - left_center)
 
-    window = max(5, size // 50)
+    window = max(5, size // 100)
     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)
-    ])
+    padded = np.pad(values, (radius, radius), mode="edge")
+    cumulative = np.cumsum(np.insert(padded, 0, 0.0))
+    smooth = (cumulative[window:] - cumulative[:-window]) / window
 
-    mean_threshold = max(
-        6.0 * np.hypot(left_spread, right_spread) / np.sqrt(edge_count),
+    effect_multiplier = 0.5 if corroborated else 1.5
+    practical_shift = max(
+        effect_multiplier * noise,
         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(
+    if difference > practical_shift:
+        tolerance_multiplier = 0.25 if corroborated else 0.75
+        tolerance = max(tolerance_multiplier * noise, 0.05 * difference)
+        smooth_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])
+        candidate = smooth_distance > tolerance
+        if not corroborated:
+            raw_distance = np.minimum(
+                np.abs(values - left_center), np.abs(values - right_center)
             )
+            candidate &= raw_distance > tolerance
+    else:
+        baseline = np.concatenate((values[:edge_count], values[-edge_count:]))
+        center, spread = _robust_spread(baseline)
+        multiplier = 1.0 if corroborated else 2.0
         threshold = max(
-            0.1 * difference,
-            4.0 * max(left_spread, right_spread) / np.sqrt(window),
+            multiplier * spread, 1e-6 * max(abs(center), 1.0), 1e-12
         )
-        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)
-
+        candidate = np.abs(smooth - center) > threshold
+        if not corroborated:
+            candidate &= np.abs(values - center) > threshold
+
+    if corroborated and bridge:
+        candidate = _bridge_mask(candidate, max(1, size // 20))
+    return _clean_mask(candidate)
+
+
+def potential_abnormal_mask(values, corroborated=False):
+    """Locate persistent potential-energy transitions or abnormal plateaus."""
+    return _persistent_change_mask(values, corroborated=corroborated)
+
+
+def structural_abnormal_mask(lengths, volume):
+    """Find dominant transition regions supported by multiple cell measures."""
+    components = [np.asarray(lengths)[:, index] for index in range(3)]
+    components.append(np.asarray(volume))
+    masks = [
+        _persistent_change_mask(values, corroborated=True, bridge=False)
+        for values in components
+    ]
+    votes = np.sum(masks, axis=0)
+    candidate = votes >= 2
+    if not candidate.any():
+        candidate = votes >= 1
+    candidate = _bridge_mask(candidate, max(1, len(candidate) // 50))
+    return _keep_major_regions(_clean_mask(candidate))
 
 def mask_intervals(time, mask):
     """Return inclusive physical-time intervals for contiguous true mask regions."""
@@ -278,7 +339,7 @@ def _format_intervals(intervals):
 
 def find_abnormal(series, start):
     component_names = {
-        "pressure": ("x", "y", "z"),
+        "pressure": ("xx", "yy", "zz", "yz", "xz", "xy"),
         "lattice-parameter": ("a", "b", "c"),
         "lattice-angle": ("alpha", "beta", "gamma"),
     }
@@ -301,24 +362,59 @@ def find_abnormal(series, start):
 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")
+    if data.shape[1] != 18:
+        raise ValueError(f"{thermo_path} must use the official 18-column GPUMD format")
 
     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]
+    pressure = data[:, 3:9]
     lengths, angles, volume = cell_quantities(data)
     start = equilibrium_start(len(data), runs)
 
+    structural_warnings = find_abnormal({
+        "lattice-parameter": lengths,
+        "volume": volume,
+        "lattice-angle": angles,
+    }, start)
+    other_warnings = find_abnormal({
+        "temperature": temperature,
+        "pressure": pressure,
+    }, start)
+
     abnormal_mask = np.zeros(len(data), dtype=bool)
-    abnormal_mask[start:] = potential_abnormal_mask(potential[start:])
-    intervals = mask_intervals(time, abnormal_mask)
+    segment_mask = potential_abnormal_mask(potential[start:])
+    abnormal_mask[start:] = segment_mask
     warnings = []
+
+    if not segment_mask.any() and structural_warnings:
+        structural_mask = structural_abnormal_mask(
+            lengths[start:], volume[start:]
+        )
+        relaxed_energy = potential_abnormal_mask(
+            potential[start:], corroborated=True
+        )
+        overlap = relaxed_energy & structural_mask
+        if overlap.any():
+            segment_mask = _keep_major_regions(
+                _bridge_mask(overlap, max(1, len(overlap) // 20))
+            )
+            warning_prefix = "potential-energy: structurally corroborated"
+        elif structural_mask.any():
+            segment_mask = structural_mask
+            warning_prefix = "structure: mapped fallback"
+        else:
+            segment_mask = np.ones(len(potential) - start, dtype=bool)
+            warning_prefix = "structure: full equilibrium fallback"
+        abnormal_mask[start:] = segment_mask
+    else:
+        warning_prefix = "potential-energy: localized"
+
+    intervals = mask_intervals(time, abnormal_mask)
     if intervals:
         warnings.append(
-            "potential-energy: localized abnormal region(s) at "
+            f"{warning_prefix} abnormal region(s) at "
             + _format_intervals(intervals)
         )
     else:
@@ -327,13 +423,14 @@ def load_thermo(thermo_path, run_path):
             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))
+    warnings.extend(structural_warnings)
+    warnings.extend(other_warnings)
+    if warnings and not abnormal_mask.any():
+        abnormal_mask[start:] = True
+        warnings.insert(
+            0, "region mapping: full equilibrium segment used as fallback"
+        )
+
     return ThermoData(
         time=time,
         temperature=temperature,

{pymdkit-1.4.2 → pymdkit-1.4.4}/src/pymdkit/commands/compute_msd_all_groups.py

@@ -59,9 +59,11 @@ class MDAnalyzer:
         if not path.exists():
             return []
         runs = []
-        dump_interval, dump_msd, time_step = 10, None, 1.0
-        for line in path.read_text(encoding="utf-8").splitlines():
-            parts = line.split()
+        dump_interval = None
+        dump_msd = None
+        time_step = 1.0
+        for raw in path.read_text(encoding="utf-8").splitlines():
+            parts = raw.split("#", 1)[0].split()
             if not parts:
                 continue
             key = parts[0]
@@ -75,11 +77,12 @@ class MDAnalyzer:
                 runs.append({
                     "steps": int(parts[1]),
                     "dump_interval": dump_interval,
-                    "dump_msd": dump_msd or dump_interval,
+                    "dump_msd": dump_msd,
                     "time_step": time_step,
                 })
+                dump_interval = None
+                dump_msd = None
         return runs
-
     @staticmethod
     def _detect_all_groups(filepath) -> bool:
         """True if a `compute_msd ... all_groups` directive is present."""
@@ -100,19 +103,26 @@ class MDAnalyzer:
 
     @staticmethod
     def _calculate_volume(data: np.ndarray) -> np.ndarray:
-        n_cols = data.shape[1]
-        if n_cols == 12:  # orthogonal box: lx, ly, lz in cols 9-11
-            return data[:, 9] * data[:, 10] * data[:, 11]
-        if n_cols == 18:  # triclinic box: 3x3 matrix in cols 9-17
-            box = data[:, 9:18].reshape(-1, 3, 3)
-            return np.abs(np.einsum("...i,...i->...", box[:, 0],
-                                    np.cross(box[:, 1], box[:, 2])))
-        raise ValueError(f"Unsupported thermo.out format with {n_cols} columns")
+        if data.shape[1] != 18:
+            raise ValueError(
+                "thermo.out must use the official 18-column GPUMD format"
+            )
+        box = data[:, 9:18].reshape(-1, 3, 3)
+        return np.abs(np.linalg.det(box))
 
     def load_thermo_data(self, filepath) -> Tuple[float, float]:
         data = np.atleast_2d(np.loadtxt(Path(filepath)))
-        dump_interval = self.runs_info[-1]["dump_interval"] if self.runs_info else 1
-        sl = self._last_run_slice(len(data), dump_interval)
+        thermo_runs = [
+            run for run in self.runs_info
+            if run["dump_interval"] is not None
+        ]
+        if thermo_runs:
+            run = thermo_runs[-1]
+            sl = self._last_run_slice(
+                len(data), run["dump_interval"]
+            )
+        else:
+            sl = slice(0, len(data))
         self.temperature = float(np.mean(data[sl, 0]))
         self.volume = float(np.mean(self._calculate_volume(data)[sl]))
         return self.temperature, self.volume
@@ -143,8 +153,14 @@ class MDAnalyzer:
         group's worth of columns it is mapped to the diffuse-ion group.
         """
         data = np.loadtxt(Path(filepath))
-        dump_msd = self.runs_info[-1]["dump_msd"] if self.runs_info else 1
-        data = data[self._last_run_slice(len(data), dump_msd)]
+        msd_runs = [
+            run for run in self.runs_info
+            if run["dump_msd"] is not None
+        ]
+        if msd_runs:
+            data = data[self._last_run_slice(
+                len(data), msd_runs[-1]["dump_msd"]
+            )]
         times = data[:, 0] - data[0, 0]
 
         num_groups = (data.shape[1] - 1) // 6

pymdkit-1.4.4/src/pymdkit/commands/gpumd_thermo.py

@@ -0,0 +1,260 @@
+"""Export, plot, and check GPUMD thermo data."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+
+try:
+    from ._gpumd import load_thermo, mask_intervals
+except ImportError:
+    from _gpumd import load_thermo, mask_intervals
+
+COMMAND = "gpumd-thermo"
+HELP = "Export and plot GPUMD thermo.out data and warn about instability."
+
+
+def save_table(path, time, values, header):
+    values = np.asarray(values)
+    if values.ndim == 1:
+        values = values[:, None]
+    np.savetxt(path, np.column_stack([time, values]), fmt="%.10g", header=header)
+
+
+def scaled_plot_values(values, quantity, unit):
+    values = np.asarray(values, dtype=float)
+    finite = np.abs(values[np.isfinite(values)])
+    use_thousands = finite.size > 0 and float(np.max(finite)) >= 1000.0
+    if use_thousands:
+        return values / 1000.0, f"{quantity} (×10³ {unit})"
+    return values, f"{quantity} ({unit})"
+
+
+def mark_abnormal_regions(axis, intervals):
+    for begin, end in intervals:
+        axis.axvspan(
+            begin, end, color="#d9e8f5", alpha=0.85, linewidth=0, zorder=0
+        )
+        axis.text(
+            (begin + end) / 2.0,
+            0.97,
+            "abnormal region",
+            transform=axis.get_xaxis_transform(),
+            ha="center",
+            va="top",
+            fontsize=7,
+            color="#315a7d",
+            bbox={
+                "facecolor": "white",
+                "edgecolor": "none",
+                "alpha": 0.8,
+                "pad": 1.0,
+            },
+            clip_on=True,
+            zorder=4,
+        )
+
+
+def plot_thermo(path, thermo):
+    import matplotlib
+    matplotlib.use("Agg")
+    matplotlib.rcParams.update({
+        "font.family": "sans-serif",
+        "font.sans-serif": ["Arial", "Liberation Sans", "DejaVu Sans"],
+    })
+    import matplotlib.pyplot as plt
+
+    colors = ("#d22027", "#015699", "#fac00f")
+    legend_style = {
+        "loc": "best",
+        "frameon": True,
+        "facecolor": "white",
+        "edgecolor": "none",
+        "framealpha": 1.0,
+    }
+    intervals = mask_intervals(thermo.time, thermo.abnormal_mask)
+    potential, potential_label = scaled_plot_values(
+        thermo.potential, "Potential energy", "eV"
+    )
+    volume, volume_label = scaled_plot_values(
+        thermo.volume, "Volume", "ų"
+    )
+
+    fig, axes = plt.subplots(2, 3, figsize=(12, 6), dpi=100)
+
+    axes[0, 0].plot(
+        thermo.time, thermo.temperature, color=colors[1], zorder=2
+    )
+    axes[0, 0].set_ylabel("Temperature (K)")
+
+    axes[0, 1].plot(
+        thermo.time, potential, color=colors[0], zorder=2
+    )
+    axes[0, 1].set_ylabel(potential_label)
+    mark_abnormal_regions(axes[0, 1], intervals)
+
+    for index, label in enumerate(("Pxx", "Pyy", "Pzz")):
+        axes[0, 2].plot(
+            thermo.time,
+            thermo.pressure[:, index],
+            label=label,
+            color=colors[index],
+            zorder=2,
+        )
+    axes[0, 2].set_ylabel("Pressure (GPa)")
+    axes[0, 2].legend(**legend_style).set_zorder(4)
+
+    for index, label in enumerate(("a", "b", "c")):
+        axes[1, 0].plot(
+            thermo.time,
+            thermo.lengths[:, index],
+            label=label,
+            color=colors[index],
+            zorder=2,
+        )
+    axes[1, 0].set_ylabel("Lattice parameters (Å)")
+    mark_abnormal_regions(axes[1, 0], intervals)
+    axes[1, 0].legend(**legend_style).set_zorder(4)
+
+    axes[1, 1].plot(
+        thermo.time, volume, color=colors[1], zorder=2
+    )
+    axes[1, 1].set_ylabel(volume_label)
+    mark_abnormal_regions(axes[1, 1], intervals)
+
+    for index, label in enumerate(("alpha", "beta", "gamma")):
+        axes[1, 2].plot(
+            thermo.time,
+            thermo.angles[:, index],
+            label=label,
+            color=colors[index],
+            zorder=2,
+        )
+    axes[1, 2].set_ylabel("Lattice angles (degree)")
+    axes[1, 2].legend(**legend_style).set_zorder(4)
+
+    for index, axis in enumerate(axes.flat):
+        axis.set_xlabel("Time (ps)")
+        axis.text(
+            -0.14,
+            1.03,
+            f"({'abcdef'[index]})",
+            transform=axis.transAxes,
+            fontsize=12,
+            va="top",
+            ha="right",
+        )
+    fig.tight_layout()
+    fig.savefig(path, dpi=300)
+    plt.close(fig)
+
+
+def process_job(folder, thermo_name, run_name):
+    thermo = load_thermo(folder / thermo_name, folder / run_name)
+    save_table(
+        folder / "temperature.txt",
+        thermo.time,
+        thermo.temperature,
+        "time(ps) temperature(K)",
+    )
+    save_table(
+        folder / "potential-energy.txt",
+        thermo.time,
+        thermo.potential,
+        "time(ps) potential_energy(eV)",
+    )
+    save_table(
+        folder / "pressure.txt",
+        thermo.time,
+        thermo.pressure,
+        "time(ps) Pxx(GPa) Pyy(GPa) Pzz(GPa) Pyz(GPa) Pxz(GPa) Pxy(GPa)",
+    )
+    save_table(
+        folder / "lattice-parameters.txt",
+        thermo.time,
+        thermo.lengths,
+        "time(ps) a(Å) b(Å) c(Å)",
+    )
+    save_table(
+        folder / "volume.txt",
+        thermo.time,
+        thermo.volume,
+        "time(ps) volume(Å^3)",
+    )
+    save_table(
+        folder / "lattice-angles.txt",
+        thermo.time,
+        thermo.angles,
+        "time(ps) alpha(deg) beta(deg) gamma(deg)",
+    )
+    plot_thermo(folder / "thermo.png", thermo)
+
+    print(
+        f"{folder}: {len(thermo.time)} thermo record(s), "
+        f"{thermo.time[-1]:.6g} ps"
+    )
+    if thermo.warnings:
+        print("WARNING: possible abnormal fluctuation in the equilibrium segment:")
+        for warning in thermo.warnings:
+            print(f"  {warning}")
+    else:
+        print("No sustained equilibrium drift or level shift detected.")
+    print("Wrote thermo text tables and thermo.png")
+
+
+def discover_jobs(thermo_arg, run_arg):
+    thermo = Path(thermo_arg)
+    run_input = Path(run_arg)
+    if thermo.is_file() and run_input.is_file():
+        return [(thermo.parent.resolve(), thermo.name, run_input.name)]
+
+    root = Path(".").resolve()
+    jobs = sorted(
+        {
+            path.parent.resolve()
+            for path in root.rglob(thermo.name)
+            if (path.parent / run_input.name).is_file()
+        },
+        key=lambda path: (len(path.relative_to(root).parts), str(path)),
+    )
+    return [(folder, thermo.name, run_input.name) for folder in jobs]
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "-t",
+        "-thermo",
+        dest="thermo",
+        default="thermo.out",
+        help="GPUMD thermo output (default: thermo.out).",
+    )
+    parser.add_argument(
+        "-in",
+        dest="run_input",
+        default="run.in",
+        help="GPUMD run input (default: run.in).",
+    )
+
+
+def run(args) -> int:
+    jobs = discover_jobs(args.thermo, args.run_input)
+    if not jobs:
+        raise SystemExit(
+            "Error: no folder containing both thermo.out and run.in was found."
+        )
+    failures = 0
+    for folder, thermo_name, run_name in jobs:
+        try:
+            process_job(folder, thermo_name, run_name)
+        except Exception as exc:
+            failures += 1
+            print(f"{folder}: error ({exc})")
+    return 1 if failures == len(jobs) else 0
+
+
+if __name__ == "__main__":
+    _parser = argparse.ArgumentParser(description=__doc__)
+    add_arguments(_parser)
+    raise SystemExit(run(_parser.parse_args()))

pymdkit-1.4.4/src/pymdkit/commands/trj_sparse.py

@@ -0,0 +1,79 @@
+"""Deterministically sparse an XYZ trajectory by a retained-frame ratio."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+try:
+    from ._extxyz import read_blocks, write_blocks
+except ImportError:
+    from _extxyz import read_blocks, write_blocks
+
+COMMAND = "trj-sparse"
+HELP = "Retain a deterministic fraction of frames from an XYZ trajectory."
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "-it",
+        "-input-trajectory",
+        dest="input_trajectory",
+        required=True,
+        help="Input XYZ trajectory.",
+    )
+    parser.add_argument(
+        "-r",
+        "-ratio",
+        dest="ratio",
+        required=True,
+        type=float,
+        help="Fraction of frames to retain, in the interval (0, 1].",
+    )
+    parser.add_argument(
+        "-o",
+        "-output",
+        dest="output",
+        help="Output trajectory (default: sparse-<input filename>).",
+    )
+
+
+def sparse_indices(frame_count, ratio):
+    if not 0.0 < ratio <= 1.0:
+        raise ValueError("-r must be greater than 0 and no greater than 1")
+    if frame_count <= 0:
+        return []
+    output_count = max(1, int(frame_count * ratio))
+    return [int(index / ratio) for index in range(output_count)]
+
+
+def run(args) -> int:
+    input_path = Path(args.input_trajectory)
+    blocks, _ = read_blocks(input_path)
+    if not blocks:
+        raise SystemExit(f"Error: {input_path} contains no trajectory frames.")
+    try:
+        indices = sparse_indices(len(blocks), args.ratio)
+    except ValueError as exc:
+        raise SystemExit(f"Error: {exc}") from exc
+
+    output = (
+        Path(args.output)
+        if args.output
+        else input_path.with_name(f"sparse-{input_path.name}")
+    )
+    if output.resolve() == input_path.resolve():
+        raise SystemExit("Error: input and output trajectories must be different.")
+
+    write_blocks(output, blocks, indices)
+    print(
+        f"Wrote {len(indices)} of {len(blocks)} frame(s) "
+        f"({len(indices) / len(blocks):.6g}) to {output}"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    _parser = argparse.ArgumentParser(description=__doc__)
+    add_arguments(_parser)
+    raise SystemExit(run(_parser.parse_args()))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.4.2
+Version: 1.4.4
 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
@@ -73,6 +73,7 @@ directory for job sub-folders automatically.
 | `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 |
+| `trj-sparse` | Deterministically retain a requested fraction of XYZ trajectory frames |
 | `umap` | Reduce descriptor data to two dimensions with UMAP; optional FPS sampling |
 | `msd` | Diffusivity & conductivity from GPUMD MSD jobs (auto-scans `<structure>/<temp>/`) |
 | `nep-rmse` | Compute NEP energy/force/stress RMSE with terminal plots and optional candidate selection |
@@ -137,6 +138,7 @@ pmk gpumd-thermo -t thermo.out -in run.in
 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 trj-sparse -it example.xyz -r 0.5 -o sparse-example.xyz
 
 pmk rmsd a.cif b.cif                            # RMSD of two files -> rmsd.txt
 pmk rmsd vasp-opted/                            # all pairs in a folder -> rmsd.txt
@@ -175,9 +177,13 @@ When `pca` or `umap` receives `-it train.xyz`, it reads `Config_type` from every
 
 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. 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-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. Detection requires a persistent change with a meaningful magnitude relative to the robust natural energy fluctuations, so ordinary correlated thermal noise and isolated spikes are not classified as abnormal. When multiple lattice or volume measures independently show a transition, a more sensitive noise-relative potential-energy test is enabled; this avoids a fixed eV or percentage-of-total-energy threshold that would depend on system size. Lattice parameters, volume, temperature, pressure, and angles remain supporting diagnostics. Thermo plots use Arial when available, opaque legends, correct Å units, and shaded abnormal regions on potential energy, lattice parameters, and volume. Potential energy and volume are divided by 1000 and labeled ×10³ only when their absolute plotted values reach 1000. 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`. 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.
+The thermo parser follows the [official GPUMD thermo.out format](https://gpumd.org/gpumd/output_files/thermo_out.html): 18 columns are required, `pressure.txt` exports `Pxx Pyy Pzz Pyz Pxz Pxy`, box vectors are interpreted as a full 3×3 matrix, `time_step` propagates between runs, and `dump_thermo` does not.
+
+`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, frames from the structurally corroborated potential-energy region are written to `abnormal.xyz` (or `-ao`); if no energy region can be resolved, the dominant structural transition is used as a fallback so an abnormal job cannot produce an empty abnormal output. 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.
+
+`trj-sparse` keeps `max(1, floor(frame_count × ratio))` frames without rewriting their extended-XYZ content. Selection is deterministic and starts with frame zero; for 100 frames and `-r 0.5`, it writes source indices `0, 2, ..., 98`.
 
 Each command's full flag list is in `pmk <command> -help`.
 

{pymdkit-1.4.2 → pymdkit-1.4.4}/src/pymdkit.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/pymdkit/commands/substitute.py
 src/pymdkit/commands/supercell.py
 src/pymdkit/commands/symmetrize.py
 src/pymdkit/commands/trj_extract.py
+src/pymdkit/commands/trj_sparse.py
 src/pymdkit/commands/umap.py
 src/pymdkit/commands/vasp2xyz.py
 src/pymdkit/commands/vasp_fe.py

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

@@ -1,131 +0,0 @@
-"""Export, plot, and check GPUMD thermo data."""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-import numpy as np
-
-try:
-    from ._gpumd import load_thermo
-except ImportError:
-    from _gpumd import load_thermo
-
-COMMAND = "gpumd-thermo"
-HELP = "Export and plot GPUMD thermo.out data and warn about instability."
-
-
-def save_table(path, time, values, header):
-    values = np.asarray(values)
-    if values.ndim == 1:
-        values = values[:, None]
-    np.savetxt(path, np.column_stack([time, values]), fmt="%.10g", header=header)
-
-
-def plot_thermo(path, thermo):
-    import matplotlib
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-
-    colors = ("#d22027", "#015699", "#fac00f")
-    fig, axes = plt.subplots(2, 3, figsize=(12, 6), dpi=100)
-
-    axes[0, 0].plot(thermo.time, thermo.temperature, color=colors[1])
-    axes[0, 0].set_ylabel("Temperature (K)")
-    axes[0, 1].plot(thermo.time, thermo.potential / 1000.0, color=colors[0])
-    axes[0, 1].set_ylabel("Potential energy (x10^3 eV)")
-    for index, label in enumerate(("Px", "Py", "Pz")):
-        axes[0, 2].plot(thermo.time, thermo.pressure[:, index],
-                        label=label, color=colors[index])
-    axes[0, 2].set_ylabel("Pressure (GPa)")
-    axes[0, 2].legend(frameon=False)
-
-    for index, label in enumerate(("a", "b", "c")):
-        axes[1, 0].plot(thermo.time, thermo.lengths[:, index],
-                        label=label, color=colors[index])
-    axes[1, 0].set_ylabel("Lattice parameters (A)")
-    axes[1, 0].legend(frameon=False)
-    axes[1, 1].plot(thermo.time, thermo.volume / 1000.0, color=colors[1])
-    axes[1, 1].set_ylabel("Volume (x10^3 A^3)")
-    for index, label in enumerate(("alpha", "beta", "gamma")):
-        axes[1, 2].plot(thermo.time, thermo.angles[:, index],
-                        label=label, color=colors[index])
-    axes[1, 2].set_ylabel("Lattice angles (degree)")
-    axes[1, 2].legend(frameon=False)
-
-    for index, axis in enumerate(axes.flat):
-        axis.set_xlabel("Time (ps)")
-        axis.text(-0.14, 1.03, f"({'abcdef'[index]})",
-                  transform=axis.transAxes, fontsize=12, va="top", ha="right")
-    fig.tight_layout()
-    fig.savefig(path, dpi=300)
-    plt.close(fig)
-
-
-def process_job(folder, thermo_name, run_name):
-    thermo = load_thermo(folder / thermo_name, folder / run_name)
-    save_table(folder / "temperature.txt", thermo.time, thermo.temperature,
-               "time(ps) temperature(K)")
-    save_table(folder / "potential-energy.txt", thermo.time, thermo.potential,
-               "time(ps) potential_energy(eV)")
-    save_table(folder / "pressure.txt", thermo.time, thermo.pressure,
-               "time(ps) pressure_x(GPa) pressure_y(GPa) pressure_z(GPa)")
-    save_table(folder / "lattice-parameters.txt", thermo.time, thermo.lengths,
-               "time(ps) a(A) b(A) c(A)")
-    save_table(folder / "volume.txt", thermo.time, thermo.volume,
-               "time(ps) volume(A^3)")
-    save_table(folder / "lattice-angles.txt", thermo.time, thermo.angles,
-               "time(ps) alpha(deg) beta(deg) gamma(deg)")
-    plot_thermo(folder / "thermo.png", thermo)
-
-    print(f"{folder}: {len(thermo.time)} thermo record(s), {thermo.time[-1]:.6g} ps")
-    if thermo.warnings:
-        print("WARNING: possible abnormal fluctuation in the equilibrium segment:")
-        for warning in thermo.warnings:
-            print(f"  {warning}")
-    else:
-        print("No sustained equilibrium drift or level shift detected.")
-    print("Wrote thermo text tables and thermo.png")
-
-
-def discover_jobs(thermo_arg, run_arg):
-    thermo = Path(thermo_arg)
-    run_input = Path(run_arg)
-    if thermo.is_file() and run_input.is_file():
-        return [(thermo.parent.resolve(), thermo.name, run_input.name)]
-
-    root = Path(".").resolve()
-    jobs = sorted(
-        {path.parent.resolve() for path in root.rglob(thermo.name)
-         if (path.parent / run_input.name).is_file()},
-        key=lambda path: (len(path.relative_to(root).parts), str(path)),
-    )
-    return [(folder, thermo.name, run_input.name) for folder in jobs]
-
-
-def add_arguments(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("-t", "-thermo", dest="thermo", default="thermo.out",
-                        help="GPUMD thermo output (default: thermo.out).")
-    parser.add_argument("-in", dest="run_input", default="run.in",
-                        help="GPUMD run input (default: run.in).")
-
-
-def run(args) -> int:
-    jobs = discover_jobs(args.thermo, args.run_input)
-    if not jobs:
-        raise SystemExit("Error: no folder containing both thermo.out and run.in was found.")
-    failures = 0
-    for folder, thermo_name, run_name in jobs:
-        try:
-            process_job(folder, thermo_name, run_name)
-        except Exception as exc:
-            failures += 1
-            print(f"{folder}: error ({exc})")
-    return 1 if failures == len(jobs) else 0
-
-
-if __name__ == "__main__":
-    _parser = argparse.ArgumentParser(description=__doc__)
-    add_arguments(_parser)
-    raise SystemExit(run(_parser.parse_args()))