scgo 0.1.0__py3-none-any.whl

benchmark/benchmark_Pt.py

@@ -0,0 +1,101 @@
+"""Benchmark suite for platinum clusters based on reference structures.
+
+The utilities here drive SCGO against a curated Pt benchmark set and evaluate
+the recovered minima primarily through geometric agreement and, secondarily,
+relative energetic ordering. The script doubles as a pytest entry point and a
+standalone CLI for rapid regression checks while tweaking optimization knobs.
+
+Campaign outputs are written under
+``benchmark/results/<formula>_<backend>_<model>/`` (for example:
+``pt5_mace_mace_matpes_0`` or ``pt5_uma_uma-s-1p2-oc25``).
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import time
+
+import pytest
+
+from benchmark.benchmark_common import (
+    DEFAULT_CLUSTERS,
+    MIN_RECOVERY_RATE,
+    NUM_GROUND_TRUTH,
+    add_common_benchmark_cli,
+    evaluate_cluster,
+    get_benchmark_params,
+    run_benchmark_suite,
+)
+from scgo.utils.logging import get_logger
+
+BENCHMARK_SEEDS = [42, 43, 44, 45]
+MODEL_NAME: str | None = None
+BENCHMARK_BACKEND = os.environ.get("SCGO_BENCHMARK_BACKEND", "mace")
+logger = get_logger(__name__)
+
+
+@pytest.mark.parametrize(
+    "cluster_formula, seed",
+    [(c, s) for c in DEFAULT_CLUSTERS for s in BENCHMARK_SEEDS],
+)
+def test_benchmark_minima_recovery(cluster_formula: str, seed: int):
+    """Pytest entry point for validating a single cluster benchmark run."""
+    params = get_benchmark_params(
+        seed, model_name=MODEL_NAME, backend=BENCHMARK_BACKEND
+    )
+    result = evaluate_cluster(
+        cluster_formula,
+        params=params,
+        seed=seed,
+        comparator_tolerance=0.05,
+        num_ground_truth=NUM_GROUND_TRUTH,
+        verbose=True,
+    )
+
+    if result.skipped:
+        pytest.skip(result.skip_reason or "Benchmark skipped")
+
+    if not result.matched_indices:
+        pytest.skip(
+            f"No minima recovered for {cluster_formula}. Check optimizer settings.",
+        )
+
+    if result.recovery_rate < MIN_RECOVERY_RATE:
+        pytest.xfail(
+            f"Recovery rate {result.recovery_rate:.2f} below threshold {MIN_RECOVERY_RATE:.2f}.",
+        )
+
+
+def main() -> None:
+    """CLI entry point for running the Pt benchmark suite."""
+    parser = argparse.ArgumentParser(
+        description="Pt cluster geometric recovery benchmark (MACE/TorchSim or UMA/ASE GA).",
+    )
+    add_common_benchmark_cli(parser)
+    args = parser.parse_args()
+
+    params = get_benchmark_params(
+        args.seed,
+        model_name=args.model_name,
+        backend=args.backend,
+        uma_task=args.uma_task,
+    )
+    params["optimizer_params"]["ga"]["niter"] = args.niter
+    params["optimizer_params"]["ga"]["population_size"] = args.population_size
+
+    t0 = time.perf_counter()
+    run_benchmark_suite(
+        clusters=args.clusters,
+        seed=args.seed,
+        params=params,
+        verbose=True,
+        backend=args.backend,
+        uma_task=args.uma_task,
+    )
+    elapsed = time.perf_counter() - t0
+    logger.info("Benchmark wall time: %.1f s (%s)", elapsed, args.backend)
+
+
+if __name__ == "__main__":
+    main()

benchmark/benchmark_Pt_surface_graphite.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Benchmark Pt cluster search on graphite with top-layer slab relaxation.
+
+Mirrors ``benchmark/benchmark_Pt.py`` for a surface system: sweeps Pt cluster
+sizes with one seed, runs SCGO over the range, and logs per-size minima from
+the campaign. Outputs live under ``benchmark/results/pt_surface_graphite/`` (same
+layout as gas-phase benchmarks: ``<Formula>_searches`` per size). See
+``benchmark.benchmark_common.PT_SURFACE_GRAPHITE_RESULTS_DIR``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+
+from benchmark.benchmark_common import (
+    DEFAULT_CLUSTERS,
+    PT_SURFACE_GRAPHITE_RESULTS_DIR,
+    add_common_benchmark_cli,
+    apply_ga_benchmark_overrides,
+    format_ga_profile_lines,
+    get_benchmark_params,
+    load_latest_ga_profile,
+    parse_atom_count,
+)
+from scgo.runner_api import run_go_campaign
+from scgo.surface import (
+    DEFAULT_GRAPHITE_SLAB_LAYERS,
+    DEFAULT_GRAPHITE_SLAB_REPEAT_XY,
+    make_graphite_surface_config,
+)
+from scgo.utils.helpers import get_cluster_formula
+from scgo.utils.logging import get_logger
+
+DEFAULT_OUTPUT_ROOT = PT_SURFACE_GRAPHITE_RESULTS_DIR.resolve()
+
+logger = get_logger(__name__)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Run Pt-on-graphite SCGO benchmark sweep with top-layer slab relaxation."
+        )
+    )
+    add_common_benchmark_cli(parser)
+    parser.set_defaults(niter=6, population_size=24)
+    parser.add_argument("--slab-layers", type=int, default=DEFAULT_GRAPHITE_SLAB_LAYERS)
+    parser.add_argument(
+        "--slab-repeat-xy",
+        type=int,
+        default=DEFAULT_GRAPHITE_SLAB_REPEAT_XY,
+        help="In-plane supercell repeats; default is large enough for Pt4-Pt11 adsorption.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    output_root = DEFAULT_OUTPUT_ROOT
+    output_root.mkdir(parents=True, exist_ok=True)
+    clusters = args.clusters or DEFAULT_CLUSTERS
+
+    surface_config = make_graphite_surface_config(
+        slab_layers=args.slab_layers,
+        slab_repeat_xy=args.slab_repeat_xy,
+    )
+
+    base_params = get_benchmark_params(
+        args.seed,
+        model_name=args.model_name,
+        backend=args.backend,
+        uma_task=args.uma_task,
+    )
+    params = apply_ga_benchmark_overrides(
+        base_params,
+        niter=args.niter,
+        population_size=args.population_size,
+        surface_config=surface_config,
+        n_jobs_population_init=-2,
+        batch_size=4,
+    )
+
+    t0 = time.perf_counter()
+
+    logger.info("Per-size summary:")
+    total_minima = 0
+    for formula in clusters:
+        n_atoms = parse_atom_count(formula)
+        formula = get_cluster_formula(["Pt"] * n_atoms)
+        results = run_go_campaign(
+            [["Pt"] * n_atoms],
+            params=params,
+            seed=args.seed,
+            output_dir=output_root,
+            surface_config=surface_config,
+            system_type="surface_cluster",
+        )
+        minima = results.get(formula, [])
+        n_found = len(minima)
+        total_minima += n_found
+        if n_found == 0:
+            logger.info("  %s: 0 minima", formula)
+            continue
+        best_energy = minima[0][0]
+        logger.info("  %s: %d minima, best E=%.6f eV", formula, n_found, best_energy)
+        profile = load_latest_ga_profile(output_root, formula)
+        if profile:
+            for line in format_ga_profile_lines(profile, detailed=True, max_entries=8):
+                logger.info("    %s", line)
+
+    logger.info(
+        "Finished benchmark. Total minima saved across formulas: %d under %s",
+        total_minima,
+        output_root,
+    )
+    elapsed = time.perf_counter() - t0
+    logger.info("Benchmark wall time: %.1f s (%s)", elapsed, args.backend)
+
+
+if __name__ == "__main__":
+    main()