pymdkit 1.4.3__tar.gz → 1.4.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.4.3
+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. 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. 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.3 → 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. 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. 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.3 → pymdkit-1.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pymdkit"
-version = "1.4.3"
+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.3 → pymdkit-1.4.4}/src/pymdkit/__init__.py

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

{pymdkit-1.4.3 → 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 persistent potential-energy transitions or abnormal plateaus."""
+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)):
@@ -207,8 +254,6 @@ def potential_abnormal_mask(values):
     noise = max(left_spread, right_spread, 1e-12)
     difference = abs(right_center - left_center)
 
-    # Average over 1% of the segment so isolated thermal excursions cannot
-    # trigger a warning. Raw values are used again to refine the boundaries.
     window = max(5, size // 100)
     if window % 2 == 0:
         window += 1
@@ -217,33 +262,58 @@ def potential_abnormal_mask(values):
     cumulative = np.cumsum(np.insert(padded, 0, 0.0))
     smooth = (cumulative[window:] - cumulative[:-window]) / window
 
+    effect_multiplier = 0.5 if corroborated else 1.5
     practical_shift = max(
-        1.5 * noise,
+        effect_multiplier * noise,
         1e-6 * max(abs(left_center), abs(right_center), 1.0),
     )
     if difference > practical_shift:
-        # The ends are two meaningfully different stable plateaus. Keep only
-        # the persistent transition between them.
-        tolerance = max(0.75 * noise, 0.05 * difference)
+        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)
         )
-        raw_distance = np.minimum(
-            np.abs(values - left_center), np.abs(values - right_center)
-        )
-        return _clean_mask(
-            (smooth_distance > tolerance) & (raw_distance > tolerance)
+        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(
+            multiplier * spread, 1e-6 * max(abs(center), 1.0), 1e-12
         )
+        candidate = np.abs(smooth - center) > threshold
+        if not corroborated:
+            candidate &= np.abs(values - center) > threshold
 
-    # The ends share one baseline. Detect only persistent excursions whose
-    # magnitude is at least twice the natural robust fluctuation scale.
-    baseline = np.concatenate((values[:edge_count], values[-edge_count:]))
-    center, spread = _robust_spread(baseline)
-    threshold = max(2.0 * spread, 1e-6 * max(abs(center), 1.0), 1e-12)
-    return _clean_mask(
-        (np.abs(smooth - center) > threshold)
-        & (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."""
@@ -269,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"),
     }
@@ -292,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:
@@ -318,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.3 → 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.3 → pymdkit-1.4.4/src/pymdkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdkit
-Version: 1.4.3
+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. 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. 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.3 → 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.3/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()))