| import argparse |
| import json |
| import sys |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
| from ase import Atoms |
| from ase.build import make_supercell |
| from ase.data import atomic_numbers, covalent_radii |
| from ase.io import write |
| from ase.optimize import LBFGS |
| from ase.filters import FrechetCellFilter |
| from ase.units import GPa |
| from mace.calculators import MACECalculator |
| from pyxtal import pyxtal as pyxtal_cls |
| from pyxtal.tolerance import Tol_matrix |
|
|
|
|
| def log(msg): |
| print(msg, flush=True) |
|
|
|
|
| |
| |
| |
|
|
| def scale_to_covalent_radii(atoms: Atoms) -> Atoms: |
| """Isotropically rescale so nearest-neighbour distance matches sum of covalent radii.""" |
| atoms = atoms.copy() |
| sc = make_supercell(atoms, 2 * np.eye(3)) |
| distances = sc.get_all_distances(mic=True) |
| np.fill_diagonal(distances, np.inf) |
|
|
| radii = np.array( |
| [covalent_radii[atomic_numbers[s]] for s in sc.get_chemical_symbols()] |
| ) |
| target_matrix = radii[:, None] + radii[None, :] |
|
|
| closest_idx = np.unravel_index(np.argmin(distances), distances.shape) |
| min_dist = distances[closest_idx] |
| target_bond = target_matrix[closest_idx] |
|
|
| if min_dist <= 0.0: |
| raise ValueError("Degenerate geometry") |
|
|
| atoms.set_cell(atoms.cell * (target_bond / min_dist), scale_atoms=True) |
| return atoms |
|
|
|
|
| def gen_random_structure( |
| composition: dict[str, int], |
| seed: int | None = None, |
| max_attempts: int = 100, |
| volume_factor: float = 0.35, |
| ) -> Atoms: |
| """Generate a random periodic crystal via PyXtal with random space groups.""" |
| rng = np.random.default_rng(seed) |
| species = list(composition.keys()) |
| num_atoms = list(composition.values()) |
| custom_tol = Tol_matrix(prototype="atomic", factor=1.0) |
|
|
| for attempt in range(max_attempts): |
| sg = int(rng.integers(1, 231)) |
| try: |
| crystal = pyxtal_cls() |
| crystal.from_random( |
| dim=3, |
| group=sg, |
| species=species, |
| numIons=num_atoms, |
| random_state=int(rng.integers(0, 2**31)), |
| tm=custom_tol, |
| max_count=10, |
| factor=volume_factor, |
| ) |
| if not crystal.valid: |
| continue |
| atoms = crystal.to_ase() |
| atoms.pbc = True |
| atoms = scale_to_covalent_radii(atoms) |
| atoms.info["space_group"] = sg |
| return atoms |
| except Exception: |
| continue |
|
|
| raise RuntimeError( |
| f"Failed to generate structure for {composition} after {max_attempts} attempts" |
| ) |
|
|
|
|
| def generate_random_structures( |
| compositions: list[dict[str, int]], |
| n_per_composition: int, |
| seed: int = 42, |
| ) -> list[Atoms]: |
| """Generate n_per_composition random structures for each composition.""" |
| rng = np.random.default_rng(seed) |
| all_structures = [] |
|
|
| for comp in compositions: |
| label = "-".join(f"{k}{v}" for k, v in sorted(comp.items())) |
| log(f" Composition {label}: generating {n_per_composition} structures...") |
| n_success = 0 |
| n_fail = 0 |
| for i in range(n_per_composition): |
| try: |
| atoms = gen_random_structure( |
| comp, |
| seed=int(rng.integers(0, 2**31)), |
| ) |
| formula = atoms.get_chemical_formula() |
| sg = atoms.info.get("space_group", "?") |
| atoms.info["label"] = f"{formula}_rss_{i}" |
| atoms.info["composition"] = label |
| atoms.info["stage"] = "initial" |
| all_structures.append(atoms) |
| n_success += 1 |
| except Exception as exc: |
| n_fail += 1 |
| if n_fail <= 3: |
| log(f" Failed #{i}: {exc}") |
| log(f" Done: {n_success} succeeded, {n_fail} failed") |
|
|
| log(f" Total: {len(all_structures)} initial structures") |
| return all_structures |
|
|
|
|
| |
| |
| |
|
|
| def relax_rattle_cycle( |
| atoms: Atoms, |
| calc, |
| n_cycles: int = 3, |
| fmax: float = 1e-3, |
| max_steps_per_cycle: int = 500, |
| rattle_stdev: float = 0.05, |
| rattle_seed: int = 42, |
| max_time: float = 120.0, |
| ) -> Atoms: |
| """ |
| Relax with interleaved rattle perturbations to escape local minima. |
| |
| Pattern: relax -> rattle -> relax -> rattle -> ... -> final relax |
| Rattle amplitude decays by 0.5x each cycle. |
| Returns the lowest-energy structure found across all cycles. |
| Bails out early if energy/volume diverge or wall-clock exceeds max_time. |
| """ |
| atoms = atoms.copy() |
| atoms.calc = calc |
| rng = np.random.default_rng(rattle_seed) |
| best_energy = np.inf |
| best_atoms = atoms.copy() |
| t_start = time.time() |
|
|
| for cycle in range(n_cycles): |
| if time.time() - t_start > max_time: |
| log(f" Timeout after {time.time()-t_start:.0f}s, stopping early") |
| break |
| try: |
| filtered = FrechetCellFilter(atoms, scalar_pressure=0.1 * GPa) |
| opt = LBFGS(filtered, logfile=None) |
| converged = opt.run(fmax=fmax, steps=max_steps_per_cycle) |
|
|
| e = atoms.get_potential_energy() / len(atoms) |
| v = atoms.get_volume() / len(atoms) |
|
|
| if abs(e) > 1e4 or v < 0.01 or v > 1e4: |
| log(f" Cycle {cycle}: runaway detected (E/at={e:.1f}, V/at={v:.2f}), stopping") |
| break |
|
|
| if e < best_energy: |
| best_energy = e |
| best_atoms = atoms.copy() |
| best_atoms.calc = None |
| best_atoms.info["energy_per_atom"] = float(e) |
| best_atoms.info["volume_per_atom"] = float(v) |
| best_atoms.info["converged"] = bool(converged) |
| best_atoms.info["relax_cycle"] = cycle |
| best_atoms.info["n_steps"] = opt.nsteps |
|
|
| if cycle < n_cycles - 1: |
| stdev = rattle_stdev * (0.5 ** cycle) |
| atoms.rattle(stdev=stdev, rng=rng) |
|
|
| except Exception as exc: |
| log(f" Cycle {cycle} failed: {exc}") |
| break |
|
|
| return best_atoms |
|
|
|
|
| def relax_structures( |
| structures: list[Atoms], |
| calc, |
| out_dir: Path, |
| n_cycles: int = 3, |
| fmax: float = 1e-3, |
| max_steps_per_cycle: int = 500, |
| rattle_stdev: float = 0.05, |
| seed: int = 42, |
| ) -> list[Atoms]: |
| """Relax all structures, writing each result incrementally.""" |
| relaxed = [] |
| failed = [] |
| rng = np.random.default_rng(seed) |
| n_total = len(structures) |
| traj_path = out_dir / "relaxed_structures.xyz" |
|
|
| for idx, atoms in enumerate(structures): |
| label = atoms.info.get("label", f"struct_{idx}") |
| comp = atoms.info.get("composition", "?") |
| t0 = time.time() |
| try: |
| result = relax_rattle_cycle( |
| atoms, |
| calc, |
| n_cycles=n_cycles, |
| fmax=fmax, |
| max_steps_per_cycle=max_steps_per_cycle, |
| rattle_stdev=rattle_stdev, |
| rattle_seed=int(rng.integers(0, 2**31)), |
| ) |
| result.info["label"] = label |
| result.info["composition"] = comp |
| result.info["stage"] = "relaxed" |
| dt = time.time() - t0 |
| e = result.info.get("energy_per_atom", np.nan) |
| v = result.info.get("volume_per_atom", np.nan) |
| conv = result.info.get("converged", False) |
| steps = result.info.get("n_steps", "?") |
| log(f" [{idx+1}/{n_total}] {label}: E/at={e:.4f} eV V/at={v:.2f} A3 conv={conv} steps={steps} ({dt:.1f}s)") |
| relaxed.append(result) |
| try: |
| write(traj_path, result, format="extxyz", append=True) |
| except Exception as write_exc: |
| log(f" [{idx+1}/{n_total}] {label}: write failed — {write_exc}") |
| except Exception as exc: |
| dt = time.time() - t0 |
| log(f" [{idx+1}/{n_total}] {label}: FAILED ({dt:.1f}s) — {exc}") |
| failed.append({"label": label, "error": str(exc)}) |
|
|
| log(f" Relaxation complete: {len(relaxed)} succeeded, {len(failed)} failed") |
| return relaxed |
|
|
|
|
| |
| |
| |
|
|
| def analyse_results(relaxed: list[Atoms], out_dir: Path): |
| """Compute and save energy-volume data; flag possible energy holes.""" |
| records = [] |
| for atoms in relaxed: |
| records.append({ |
| "label": atoms.info.get("label", "unknown"), |
| "composition": atoms.info.get("composition", "unknown"), |
| "formula": atoms.get_chemical_formula(), |
| "n_atoms": len(atoms), |
| "energy_per_atom_eV": atoms.info.get("energy_per_atom", np.nan), |
| "volume_per_atom_A3": atoms.info.get("volume_per_atom", np.nan), |
| "converged": atoms.info.get("converged", False), |
| }) |
|
|
| csv_path = out_dir / "rss_results.csv" |
| with open(csv_path, "w") as f: |
| if records: |
| header = list(records[0].keys()) |
| f.write(",".join(header) + "\n") |
| for rec in records: |
| f.write(",".join(str(rec[k]) for k in header) + "\n") |
| log(f" Results saved to {csv_path}") |
|
|
| compositions = sorted(set(r["composition"] for r in records)) |
| for comp in compositions: |
| energies = np.array([ |
| r["energy_per_atom_eV"] for r in records |
| if r["composition"] == comp and np.isfinite(r["energy_per_atom_eV"]) |
| ]) |
| if len(energies) == 0: |
| continue |
| median_e = np.median(energies) |
| iqr = np.percentile(energies, 75) - np.percentile(energies, 25) |
| threshold = median_e - 5 * max(iqr, 0.5) |
| n_suspicious = int(np.sum(energies < threshold)) |
| log(f"\n [{comp}] n={len(energies)} min={np.min(energies):.4f} median={median_e:.4f} max={np.max(energies):.4f} eV/atom") |
| if n_suspicious > 0: |
| log(f" WARNING: {n_suspicious} structures below {threshold:.4f} eV/atom — possible energy holes!") |
| for r in records: |
| if r["composition"] == comp and r["energy_per_atom_eV"] < threshold: |
| log(f" {r['label']}: {r['energy_per_atom_eV']:.4f} eV/atom") |
|
|
|
|
| |
| |
| |
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Random Structure Search with MACE") |
| parser.add_argument("model_path", type=str, help="Path to MACE .model file") |
| parser.add_argument("--device", type=str, default="cuda", choices=["cuda", "cpu"]) |
| parser.add_argument("--dtype", type=str, default="float64", choices=["float32", "float64"]) |
| parser.add_argument("--compositions", type=str, default=None, |
| help="Explicit compositions as 'Na4Cl4,Na2Cl6,Na8,Cl8,...' — " |
| "element followed by count, comma-separated") |
| parser.add_argument("--elements", type=str, default=None, |
| help="Comma-separated elements (e.g. 'Na,Cl') to auto-enumerate compositions") |
| parser.add_argument("--min-atoms", type=int, default=8, |
| help="Min total atoms per cell when using --elements (default: 8)") |
| parser.add_argument("--max-atoms", type=int, default=12, |
| help="Max total atoms per cell when using --elements (default: 12)") |
| parser.add_argument("--total-structures", type=int, default=500, |
| help="Target total structures when using --elements (default: 500)") |
| parser.add_argument("--random-compositions", type=str, default=None, |
| help="Element pool for random composition sampling (e.g. 'Li,P,S,Ge,Cl,As,Si,Sn')") |
| parser.add_argument("--n-compositions", type=int, default=10, |
| help="Number of random compositions to sample (default: 10)") |
| parser.add_argument("--n-species", type=int, default=3, |
| help="Number of species per random composition (default: 3)") |
| parser.add_argument("--anchor-element", type=str, default=None, |
| help="Element to include in most compositions (e.g. 'Li')") |
| parser.add_argument("--n-per-composition", type=int, default=None, |
| help="Number of random structures per composition (required with --compositions)") |
| parser.add_argument("--n-cycles", type=int, default=3, |
| help="Number of relax-rattle cycles") |
| parser.add_argument("--fmax", type=float, default=1e-3, |
| help="Force convergence threshold (eV/A)") |
| parser.add_argument("--max-steps", type=int, default=500, |
| help="Max optimizer steps per relax cycle") |
| parser.add_argument("--rattle-stdev", type=float, default=0.05, |
| help="Initial rattle amplitude (A), halved each cycle") |
| parser.add_argument("--head", type=str, default=None, |
| help="Head name for multi-head models (e.g. 'omat_pbe')") |
| parser.add_argument("--seed", type=int, default=42) |
| parser.add_argument("--out-dir", type=str, default="rss_output") |
| args = parser.parse_args() |
|
|
| out_dir = Path(args.out_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| if args.compositions: |
| compositions = parse_compositions(args.compositions) |
| n_per_composition = args.n_per_composition if args.n_per_composition else 100 |
| elif args.random_compositions: |
| pool = [e.strip() for e in args.random_compositions.split(",")] |
| compositions = sample_random_compositions( |
| element_pool=pool, |
| n_compositions=args.n_compositions, |
| n_species=args.n_species, |
| min_atoms=args.min_atoms, |
| max_atoms=args.max_atoms, |
| anchor_element=args.anchor_element, |
| seed=args.seed, |
| ) |
| n_per_composition = args.n_per_composition if args.n_per_composition else 50 |
| log(f" Sampled {len(compositions)} random compositions from {pool}, " |
| f"{n_per_composition} structures each") |
| elif args.elements: |
| elements = [e.strip() for e in args.elements.split(",")] |
| compositions = enumerate_compositions(elements, args.min_atoms, args.max_atoms) |
| n_per_composition = max(1, args.total_structures // len(compositions)) |
| log(f" Auto-enumerated {len(compositions)} compositions from {elements}, " |
| f"{n_per_composition} structures each (target total={args.total_structures})") |
| else: |
| parser.error("Either --compositions, --elements, or --random-compositions is required") |
|
|
| log("=" * 70) |
| log("Random Structure Search") |
| log("=" * 70) |
| log(f"Model: {args.model_path}") |
| log(f"Device: {args.device}") |
| log(f"Compositions: {len(compositions)} total") |
| for comp in compositions: |
| label = "-".join(f"{k}{v}" for k, v in sorted(comp.items())) |
| log(f" {label}") |
| log(f"N per comp: {n_per_composition}") |
| log(f"Relax cycles: {args.n_cycles} (fmax={args.fmax} eV/A, max_steps={args.max_steps})") |
| log(f"Rattle: stdev={args.rattle_stdev} A (halved each cycle)") |
| log(f"Seed: {args.seed}") |
| log(f"Output: {out_dir}") |
| log("=" * 70) |
|
|
| |
| log("\n>>> Stage 1: Generating random structures...") |
| t0 = time.time() |
| structures = generate_random_structures( |
| compositions=compositions, |
| n_per_composition=n_per_composition, |
| seed=args.seed, |
| ) |
| write(out_dir / "initial_structures.xyz", structures, format="extxyz") |
| log(f" Saved initial structures ({time.time()-t0:.1f}s)") |
|
|
| |
| log("\n>>> Stage 2: Relaxing structures...") |
| calc_kwargs = dict( |
| model_paths=args.model_path, |
| device=args.device, |
| default_dtype=args.dtype, |
| ) |
| if args.head: |
| calc_kwargs["head"] = args.head |
| calc = MACECalculator(**calc_kwargs) |
| t0 = time.time() |
| relaxed = relax_structures( |
| structures, |
| calc, |
| out_dir, |
| n_cycles=args.n_cycles, |
| fmax=args.fmax, |
| max_steps_per_cycle=args.max_steps, |
| rattle_stdev=args.rattle_stdev, |
| seed=args.seed, |
| ) |
| log(f" Total relaxation time: {time.time()-t0:.1f}s") |
|
|
| |
| log("\n>>> Stage 3: Analysis...") |
| analyse_results(relaxed, out_dir) |
| log("\nDone!") |
|
|
|
|
| def parse_compositions(comp_str: str) -> list[dict[str, int]]: |
| """Parse 'Na4Cl4,Na8,Cl12' into [{'Na': 4, 'Cl': 4}, {'Na': 8}, {'Cl': 12}].""" |
| import re |
| compositions = [] |
| for part in comp_str.split(","): |
| part = part.strip() |
| comp = {} |
| for match in re.finditer(r"([A-Z][a-z]?)(\d+)", part): |
| elem, count = match.group(1), int(match.group(2)) |
| comp[elem] = count |
| if comp: |
| compositions.append(comp) |
| else: |
| raise ValueError(f"Could not parse composition: '{part}'") |
| return compositions |
|
|
|
|
| def enumerate_compositions( |
| elements: list[str], |
| min_atoms: int = 8, |
| max_atoms: int = 12, |
| ) -> list[dict[str, int]]: |
| """Enumerate all stoichiometric combinations of elements with total atoms in [min_atoms, max_atoms]. |
| |
| Each element present in a composition has at least 1 atom. Pure-element |
| compositions (single species) are included. |
| """ |
| from itertools import combinations_with_replacement |
|
|
| compositions = [] |
| n_elems = len(elements) |
|
|
| for n_total in range(min_atoms, max_atoms + 1): |
| if n_elems == 1: |
| compositions.append({elements[0]: n_total}) |
| continue |
| for n_sub in range(1, n_elems + 1): |
| for elem_subset in combinations_with_replacement(elements, n_sub): |
| unique = sorted(set(elem_subset)) |
| _enumerate_partitions(unique, n_total, {}, compositions) |
|
|
| seen = set() |
| unique_compositions = [] |
| for comp in compositions: |
| key = tuple(sorted(comp.items())) |
| if key not in seen: |
| seen.add(key) |
| unique_compositions.append(comp) |
|
|
| return unique_compositions |
|
|
|
|
| def _enumerate_partitions( |
| elements: list[str], |
| n_total: int, |
| current: dict[str, int], |
| results: list[dict[str, int]], |
| ): |
| """Recursively partition n_total atoms among elements (each gets >= 1).""" |
| if len(elements) == 1: |
| if n_total >= 1: |
| comp = dict(current) |
| comp[elements[0]] = n_total |
| results.append(comp) |
| return |
| elem = elements[0] |
| remaining = elements[1:] |
| min_for_rest = len(remaining) |
| for count in range(1, n_total - min_for_rest + 1): |
| current[elem] = count |
| _enumerate_partitions(remaining, n_total - count, current, results) |
| if elem in current: |
| del current[elem] |
|
|
|
|
| def sample_random_compositions( |
| element_pool: list[str], |
| n_compositions: int = 10, |
| n_species: int = 3, |
| min_atoms: int = 8, |
| max_atoms: int = 12, |
| anchor_element: str | None = None, |
| anchor_fraction: float = 0.7, |
| seed: int = 42, |
| ) -> list[dict[str, int]]: |
| """Sample random compositions from an element pool. |
| |
| Generates diverse compositions by picking n_species elements per composition |
| and assigning random atom counts summing to min_atoms..max_atoms. |
| |
| Sampling strategy (3 tiers for chemical diversity): |
| - Tier 1 (~anchor_fraction of compositions): anchor_element + 2 random others |
| - Tier 2 (remaining): any 3 random elements from pool, no anchor constraint |
| |
| Within each composition, atom counts are drawn from a Dirichlet distribution |
| (alpha=1 = uniform on the simplex), then rounded to integers >= 1. This gives |
| a spread of stoichiometries rather than always near-equal splits. |
| """ |
| rng = np.random.default_rng(seed) |
| compositions = [] |
| seen = set() |
|
|
| n_anchored = int(n_compositions * anchor_fraction) if anchor_element else 0 |
| non_anchor_pool = [e for e in element_pool if e != anchor_element] |
|
|
| for i in range(n_compositions * 10): |
| if len(compositions) >= n_compositions: |
| break |
|
|
| if len(compositions) < n_anchored and anchor_element: |
| others = list(rng.choice(non_anchor_pool, size=n_species - 1, replace=False)) |
| species = [anchor_element] + others |
| else: |
| species = list(rng.choice(element_pool, size=n_species, replace=False)) |
|
|
| species = sorted(species) |
| n_total = int(rng.integers(min_atoms, max_atoms + 1)) |
|
|
| alphas = np.ones(len(species)) |
| fractions = rng.dirichlet(alphas) |
| raw_counts = fractions * n_total |
| counts = np.maximum(np.round(raw_counts).astype(int), 1) |
| diff = n_total - counts.sum() |
| if diff > 0: |
| for _ in range(diff): |
| counts[rng.integers(len(counts))] += 1 |
| elif diff < 0: |
| for _ in range(-diff): |
| idx = rng.choice(np.where(counts > 1)[0]) |
| counts[idx] -= 1 |
|
|
| comp = {str(s): int(c) for s, c in zip(species, counts)} |
| key = tuple(sorted(comp.items())) |
| if key not in seen: |
| seen.add(key) |
| compositions.append(comp) |
|
|
| return compositions |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
