科研 Skill

ASE原子模拟环境

ase-atomistic

Builds and analyzes atomic structures with ASE: geometry optimization, NEB transition states, and MD trajectories. Use for setting up or analyzing atomistic simulations.

发布者 Codar安全审核通过v0.1.0更新于 2026-11-18

SKILL.md

ASE — Atomic Simulation Environment

The Atomic Simulation Environment (ASE) is the de-facto Python toolkit for setting up, running, and analyzing atomistic simulations. This skill covers structure building, geometry optimization, transition state searches, molecular dynamics, and trajectory analysis — with the EMT empirical potential as a dependency-free calculator.


1. Building Atomic Structures

ASE provides factory functions for common structure types.

from ase import Atoms
from ase.build import bulk, surface, molecule, fcc111, add_adsorbate
from ase.visualize import view  # requires ASE GUI or nglview in Jupyter
import numpy as np


def build_structures_demo():
    """
    Demonstrate building bulk, surface, molecule, and nanoparticle structures.
    """
    # --- Bulk FCC copper ---
    cu_bulk = bulk("Cu", crystalstructure="fcc", a=3.615, cubic=True)
    print(f"Cu bulk: {len(cu_bulk)} atoms, cell = {cu_bulk.cell.diagonal().round(3)}")

    # --- FCC(111) surface slab ---
    def build_fcc_slab(element, miller, layers, vacuum=10.0, supercell=(2, 2)):
        """
        Build an FCC surface slab.

        Parameters
        ----------
        element : str
            Chemical symbol, e.g. 'Pt', 'Cu', 'Au'.
        miller : tuple
            Miller index, e.g. (1, 1, 1).
        layers : int
            Number of atomic layers.
        vacuum : float
            Vacuum thickness in Angstrom (added on both sides).
        supercell : tuple
            (nx, ny) supercell repetitions.

        Returns
        -------
        slab : ase.Atoms
            Surface slab with vacuum.
        """
        from ase.build import fcc111, fcc110, fcc100
        miller_map = {
            (1, 1, 1): fcc111,
            (1, 1, 0): fcc110,
            (1, 0, 0): fcc100,
        }
        builder = miller_map.get(miller, fcc111)
        slab = builder(element, size=(supercell[0], supercell[1], layers), vacuum=vacuum)
        return slab

    pt_slab = build_fcc_slab("Pt", (1, 1, 1), layers=4, vacuum=12.0, supercell=(3, 3))
    print(f"Pt(111) slab: {len(pt_slab)} atoms")
    print(f"  Cell: {pt_slab.cell.diagonal().round(3)} Å")
    print(f"  Species: {set(pt_slab.get_chemical_symbols())}")

    # --- Small molecules ---
    co = molecule("CO")
    h2o = molecule("H2O")
    print(f"\nCO bond length: {co.get_distance(0, 1):.4f} Å")
    print(f"H2O O-H bond:  {h2o.get_distance(0, 1):.4f} Å")
    print(f"H2O H-O-H angle: {h2o.get_angle(1, 0, 2):.2f}°")

    # --- Custom Atoms object ---
    h2 = Atoms(
        symbols="HH",
        positions=[[0, 0, 0], [0, 0, 0.74]],
        cell=[10, 10, 10],
        pbc=False,
    )
    print(f"\nH2 molecule: bond = {h2.get_distance(0, 1):.4f} Å")

    # --- Nanoparticle (FCC icosahedron) ---
    from ase.cluster import Icosahedron
    np_Au = Icosahedron("Au", noshells=3)
    print(f"\nAu nanoparticle: {len(np_Au)} atoms (Icosahedron, 3 shells)")

    return pt_slab, co, h2


if __name__ == "__main__":
    slab, co, h2 = build_structures_demo()

2. Reading and Writing Structure Files

from ase.io import read, write
from ase.build import bulk, molecule
import os


def io_demo(output_dir="/tmp/ase_io_demo"):
    """
    Demonstrate reading and writing structure files in various formats.

    Supported formats: CIF, POSCAR/CONTCAR, XYZ, extXYZ, cube, cif, pdb, ...
    """
    os.makedirs(output_dir, exist_ok=True)

    # Build a test structure
    cu = bulk("Cu", "fcc", a=3.615)
    h2o = molecule("H2O")

    # --- Write formats ---
    write(f"{output_dir}/cu_bulk.vasp", cu, format="vasp")          # POSCAR
    write(f"{output_dir}/cu_bulk.cif", cu, format="cif")            # CIF
    write(f"{output_dir}/h2o.xyz", h2o, format="xyz")               # XYZ
    write(f"{output_dir}/h2o_ext.xyz", h2o, format="extxyz")        # Extended XYZ

    print(f"Wrote files to {output_dir}/")
    for fname in os.listdir(output_dir):
        fpath = f"{output_dir}/{fname}"
        atoms = read(fpath)
        print(f"  {fname:25s}: {len(atoms):3d} atoms, formula={atoms.get_chemical_formula()}")

    # --- Read a trajectory (multiple frames) ---
    from ase.io.trajectory import Trajectory
    from ase.calculators.emt import EMT
    from ase.optimize import BFGS

    traj_path = f"{output_dir}/test_traj.traj"
    atoms = h2o.copy()
    atoms.calc = EMT()

    with Trajectory(traj_path, "w", atoms) as traj:
        # Perturb and write a few frames
        rng = np.random.default_rng(0)
        for i in range(5):
            atoms.positions += 0.05 * rng.standard_normal(atoms.positions.shape)
            atoms.get_potential_energy()  # trigger calc
            traj.write(atoms)

    # Read back all frames
    frames = read(traj_path, index=":")
    print(f"\nTrajectory: {len(frames)} frames, {len(frames[0])} atoms per frame")
    energies = [f.get_potential_energy() for f in frames]
    print(f"Energies: {[f'{e:.4f}' for e in energies]}")

    return output_dir


import numpy as np
if __name__ == "__main__":
    io_demo()

3. Geometry Optimization

from ase.calculators.emt import EMT
from ase.optimize import BFGS, LBFGS, BFGSLineSearch
from ase.build import molecule
from ase.constraints import FixAtoms
import numpy as np


def optimize_geometry(atoms, calculator=None, fmax=0.01, optimizer="BFGS",
                      max_steps=500, trajectory_file=None):
    """
    Optimize atomic positions to minimize forces.

    Parameters
    ----------
    atoms : ase.Atoms
        Structure to optimize.
    calculator : ase Calculator or None
        If None, uses EMT (works for metals).
    fmax : float
        Convergence criterion: max force component in eV/Å.
    optimizer : str
        'BFGS', 'LBFGS', or 'BFGSLineSearch'.
    max_steps : int
        Maximum optimization steps.
    trajectory_file : str or None
        Path to save trajectory; None = no save.

    Returns
    -------
    atoms : ase.Atoms (in-place modified)
    converged : bool
    """
    if calculator is None:
        calculator = EMT()

    atoms = atoms.copy()
    atoms.calc = calculator

    optimizer_map = {"BFGS": BFGS, "LBFGS": LBFGS, "BFGSLineSearch": BFGSLineSearch}
    Opt = optimizer_map.get(optimizer, BFGS)

    opt = Opt(atoms, logfile=None, trajectory=trajectory_file)
    converged = opt.run(fmax=fmax, steps=max_steps)

    e_final = atoms.get_potential_energy()
    f_max = np.abs(atoms.get_forces()).max()
    print(f"Geometry optimization ({optimizer}):")
    print(f"  Converged: {converged}")
    print(f"  Steps:     {opt.nsteps}")
    print(f"  Energy:    {e_final:.6f} eV")
    print(f"  Max force: {f_max:.6f} eV/Å")

    return atoms, converged


def optimize_molecule_demo():
    """Optimize H2O geometry and compute properties."""
    h2o = molecule("H2O")
    h2o.calc = EMT()

    print(f"Before optimization:")
    print(f"  Energy:    {h2o.get_potential_energy():.6f} eV")
    print(f"  Max force: {np.abs(h2o.get_forces()).max():.6f} eV/Å")

    h2o_opt, converged = optimize_geometry(h2o, fmax=0.001)

    print(f"\nAfter optimization:")
    print(f"  O-H bond 1: {h2o_opt.get_distance(0, 1):.4f} Å")
    print(f"  O-H bond 2: {h2o_opt.get_distance(0, 2):.4f} Å")
    print(f"  H-O-H angle: {h2o_opt.get_angle(1, 0, 2):.2f}°")
    return h2o_opt


def optimize_slab_with_constraints():
    """Optimize a surface slab with bottom layers fixed."""
    from ase.build import fcc111

    slab = fcc111("Pt", size=(2, 2, 4), vacuum=10.0)
    slab.calc = EMT()

    # Fix bottom 2 layers
    n_bottom = len(slab) // 2
    constraint = FixAtoms(indices=list(range(n_bottom)))
    slab.set_constraint(constraint)

    print(f"\nSlab optimization with FixAtoms constraint:")
    print(f"  {n_bottom} atoms fixed, {len(slab) - n_bottom} atoms free")

    slab_opt, _ = optimize_geometry(slab, fmax=0.05, optimizer="LBFGS")
    return slab_opt


if __name__ == "__main__":
    h2o_opt = optimize_molecule_demo()
    slab_opt = optimize_slab_with_constraints()

4. Nudged Elastic Band (NEB) for Transition States

import numpy as np
from ase.calculators.emt import EMT
from ase.build import fcc111, add_adsorbate, molecule
from ase.optimize import BFGS
from ase.neb import NEB
from ase.constraints import FixAtoms
import matplotlib.pyplot as plt


def run_neb(initial, final, n_images=7, calculator_class=EMT, fmax=0.05):
    """
    Run a Nudged Elastic Band calculation to find the minimum energy path.

    Parameters
    ----------
    initial : ase.Atoms
        Initial state (relaxed).
    final : ase.Atoms
        Final state (relaxed).
    n_images : int
        Number of intermediate images (not counting endpoints).
    calculator_class : callable
        ASE calculator factory, e.g. EMT.
    fmax : float
        Force convergence threshold in eV/Å.

    Returns
    -------
    images : list of ase.Atoms
        All NEB images (initial + intermediate + final).
    neb : NEB object
    """
    # Build intermediate images by interpolation
    images = [initial.copy()]
    for _ in range(n_images):
        images.append(initial.copy())
    images.append(final.copy())

    # Assign calculator to each intermediate image
    for image in images[1:-1]:
        image.calc = calculator_class()

    # Linear interpolation
    neb = NEB(images, climb=True, k=0.1)
    neb.interpolate(method="idpp")  # IDPP is smoother than linear for molecules

    # Optimize
    opt = BFGS(neb, logfile=None)
    opt.run(fmax=fmax, steps=300)

    print(f"NEB optimization steps: {opt.nsteps}")
    return images, neb


def plot_neb_path(images):
    """Plot the NEB energy profile (MEP)."""
    energies = [img.get_potential_energy() for img in images]
    e_ref = energies[0]
    reaction_coord = np.linspace(0, 1, len(energies))

    activation_barrier = max(energies) - e_ref
    reaction_energy = energies[-1] - e_ref

    fig, ax = plt.subplots(figsize=(8, 5))
    ax.plot(reaction_coord, [e - e_ref for e in energies], "o-", color="steelblue",
            lw=2, ms=8, label="NEB images")
    ax.fill_between(reaction_coord, [e - e_ref for e in energies], alpha=0.15, color="steelblue")
    ax.axhline(0, color="gray", ls="--", lw=0.8)
    ax.axhline(activation_barrier, color="red", ls=":", lw=1.5,
               label=f"Barrier = {activation_barrier:.3f} eV")
    ax.set_xlabel("Reaction Coordinate")
    ax.set_ylabel("Energy (eV)")
    ax.set_title("NEB Minimum Energy Path")
    ax.legend()

    print(f"\nNEB results:")
    print(f"  Activation barrier: {activation_barrier:.4f} eV")
    print(f"  Reaction energy:    {reaction_energy:.4f} eV")

    plt.tight_layout()
    plt.show()
    return activation_barrier, reaction_energy


def neb_demo():
    """
    Demonstrate NEB for H2 dissociation on a flat potential (EMT demo).
    Uses a simple displacement as the reaction coordinate.
    """
    from ase import Atoms

    # Initial: H2 molecule (bound)
    initial = Atoms("H2", positions=[[0, 0, 0], [0, 0, 0.74]])
    initial.calc = EMT()
    opt = BFGS(initial, logfile=None)
    opt.run(fmax=0.01)

    # Final: H atoms separated
    final = Atoms("H2", positions=[[0, 0, 0], [0, 0, 3.0]])
    final.calc = EMT()
    opt_f = BFGS(final, logfile=None)
    opt_f.run(fmax=0.01)

    print("H2 dissociation NEB:")
    print(f"  Initial energy: {initial.get_potential_energy():.4f} eV")
    print(f"  Final energy:   {final.get_potential_energy():.4f} eV")

    images, neb_obj = run_neb(initial, final, n_images=5, fmax=0.05)
    barrier, delta_e = plot_neb_path(images)
    return images


if __name__ == "__main__":
    neb_demo()

5. Molecular Dynamics

import numpy as np
from ase import Atoms, units
from ase.build import bulk, molecule
from ase.calculators.emt import EMT
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
from ase.md.verlet import VelocityVerlet
from ase.md.langevin import Langevin
from ase.io.trajectory import Trajectory
import matplotlib.pyplot as plt


def run_nvt_md(atoms, T=300, steps=1000, dt=1.0, friction=0.01,
               trajectory_file=None, log_interval=10):
    """
    Run NVT (constant temperature) molecular dynamics using Langevin thermostat.

    Parameters
    ----------
    atoms : ase.Atoms
        Structure with calculator already set.
    T : float
        Target temperature in Kelvin.
    steps : int
        Total MD steps.
    dt : float
        Timestep in femtoseconds.
    friction : float
        Langevin friction coefficient (1/fs).
    trajectory_file : str or None
        Save trajectory to this file.
    log_interval : int
        Log energy/temperature every N steps.

    Returns
    -------
    log : dict
        Dictionary with 'time', 'temperature', 'potential_energy', 'kinetic_energy'.
    """
    MaxwellBoltzmannDistribution(atoms, temperature_K=T)

    dyn = Langevin(
        atoms,
        timestep=dt * units.fs,
        temperature_K=T,
        friction=friction / units.fs,
        logfile=None,
    )

    log = {"time": [], "temperature": [], "potential_energy": [], "kinetic_energy": []}

    if trajectory_file:
        traj = Trajectory(trajectory_file, "w", atoms)
        dyn.attach(traj.write, interval=log_interval)

    def record():
        log["time"].append(dyn.get_time() / units.fs)
        log["temperature"].append(atoms.get_temperature())
        log["potential_energy"].append(atoms.get_potential_energy())
        log["kinetic_energy"].append(atoms.get_kinetic_energy())

    dyn.attach(record, interval=log_interval)
    dyn.run(steps)

    if trajectory_file:
        traj.close()

    print(f"\nNVT MD completed:")
    print(f"  Steps: {steps}, dt = {dt} fs, T_target = {T} K")
    print(f"  T_mean = {np.mean(log['temperature']):.1f} K")
    print(f"  T_std  = {np.std(log['temperature']):.2f} K")
    return log


def run_nve_md(atoms, steps=500, dt=1.0, trajectory_file=None):
    """
    Run NVE (microcanonical) MD using Velocity Verlet.
    Energy should be approximately conserved.
    """
    dyn = VelocityVerlet(atoms, timestep=dt * units.fs, logfile=None)

    log = {"time": [], "total_energy": [], "temperature": []}

    def record():
        log["time"].append(dyn.get_time() / units.fs)
        e_pot = atoms.get_potential_energy()
        e_kin = atoms.get_kinetic_energy()
        log["total_energy"].append(e_pot + e_kin)
        log["temperature"].append(atoms.get_temperature())

    dyn.attach(record, interval=5)
    dyn.run(steps)

    e_total = np.array(log["total_energy"])
    drift = (e_total[-1] - e_total[0]) / abs(e_total[0]) * 100
    print(f"\nNVE MD: total energy drift = {drift:.4f}%")
    return log


def md_demo():
    """Run NVT MD on bulk Cu and plot thermodynamic observables."""
    cu = bulk("Cu", "fcc", a=3.615, cubic=True) * (2, 2, 2)
    cu.calc = EMT()

    # Equilibrate at 500K
    MaxwellBoltzmannDistribution(cu, temperature_K=500)
    log = run_nvt_md(cu, T=500, steps=2000, dt=2.0, friction=0.02, log_interval=20)

    fig, axes = plt.subplots(2, 1, figsize=(10, 7), sharex=True)

    axes[0].plot(log["time"], log["temperature"], color="tomato", lw=0.8)
    axes[0].axhline(500, color="black", ls="--", lw=1, label="T_target = 500 K")
    axes[0].set_ylabel("Temperature (K)")
    axes[0].legend()
    axes[0].set_title("NVT MD — Bulk Cu at 500 K")

    e_pot = np.array(log["potential_energy"])
    e_kin = np.array(log["kinetic_energy"])
    axes[1].plot(log["time"], e_pot, label="Potential", color="steelblue", lw=0.8)
    axes[1].plot(log["time"], e_kin, label="Kinetic", color="darkorange", lw=0.8)
    axes[1].plot(log["time"], e_pot + e_kin, label="Total", color="black", lw=1.2, ls="--")
    axes[1].set_xlabel("Time (fs)")
    axes[1].set_ylabel("Energy (eV)")
    axes[1].legend()

    plt.tight_layout()
    plt.show()

    return log


if __name__ == "__main__":
    md_demo()

6. Trajectory Analysis: RDF, MSD, RMSD

import numpy as np
from ase.io import read
from ase.geometry import get_distances
import matplotlib.pyplot as plt


def compute_rdf(trajectory, species_pair=None, rmax=6.0, nbins=100):
    """
    Compute the radial distribution function g(r) from a trajectory.

    Parameters
    ----------
    trajectory : list of ase.Atoms
        MD frames.
    species_pair : tuple of str or None
        e.g. ('Cu', 'Cu'). If None, uses all pairs.
    rmax : float
        Maximum distance in Å.
    nbins : int
        Number of histogram bins.

    Returns
    -------
    r_centers : ndarray
        Bin center distances.
    g_r : ndarray
        RDF values.
    """
    dr = rmax / nbins
    r_edges = np.linspace(0, rmax, nbins + 1)
    r_centers = 0.5 * (r_edges[:-1] + r_edges[1:])
    hist = np.zeros(nbins)

    n_frames = len(trajectory)
    for atoms in trajectory:
        symbols = np.array(atoms.get_chemical_symbols())
        N = len(atoms)

        if species_pair is not None:
            s1, s2 = species_pair
            idx1 = np.where(symbols == s1)[0]
            idx2 = np.where(symbols == s2)[0]
        else:
            idx1 = idx2 = np.arange(N)

        for i in idx1:
            for j in idx2:
                if i >= j:
                    continue
                r = atoms.get_distance(i, j, mic=True)
                if r < rmax:
                    bin_idx = int(r / dr)
                    if bin_idx < nbins:
                        hist[bin_idx] += 2  # count both i->j and j->i

    # Normalize to ideal gas
    n_frames_norm = n_frames
    cell_volume = np.mean([atoms.get_volume() for atoms in trajectory])
    N_avg = np.mean([len(a) for a in trajectory])
    rho = N_avg / cell_volume  # number density

    for k, (r_lo, r_hi) in enumerate(zip(r_edges[:-1], r_edges[1:])):
        shell_vol = 4 * np.pi / 3 * (r_hi**3 - r_lo**3)
        norm = rho * shell_vol * N_avg * n_frames_norm
        g_r_k = hist[k] / (norm + 1e-12)
        hist[k] = g_r_k

    return r_centers, hist


def compute_msd(trajectory, species=None):
    """
    Compute the Mean Squared Displacement as a function of time lag.

    Parameters
    ----------
    trajectory : list of ase.Atoms
        MD frames (equal time spacing assumed).
    species : str or None
        If given, compute MSD only for this element.

    Returns
    -------
    tau : ndarray
        Time lags (in frame units).
    msd : ndarray
        MSD in Ų.
    """
    n_frames = len(trajectory)
    if species is not None:
        ref_atoms = trajectory[0]
        indices = [i for i, s in enumerate(ref_atoms.get_chemical_symbols()) if s == species]
    else:
        indices = list(range(len(trajectory[0])))

    positions = np.array([atoms.positions[indices] for atoms in trajectory])

    max_lag = n_frames // 2
    msd = np.zeros(max_lag)
    counts = np.zeros(max_lag)

    for lag in range(1, max_lag):
        disp = positions[lag:] - positions[:n_frames - lag]
        msd[lag] = np.mean(np.sum(disp**2, axis=-1))
        counts[lag] = n_frames - lag

    return np.arange(max_lag), msd


def compute_rmsd(trajectory, reference=None):
    """
    Compute RMSD of each frame relative to a reference structure.

    Returns rmsd array in Å.
    """
    if reference is None:
        reference = trajectory[0]
    ref_pos = reference.positions

    rmsd_values = []
    for atoms in trajectory:
        disp = atoms.positions - ref_pos
        rmsd = np.sqrt(np.mean(np.sum(disp**2, axis=-1)))
        rmsd_values.append(rmsd)

    return np.array(rmsd_values)


def trajectory_analysis_demo():
    """Generate an MD trajectory and perform full analysis."""
    from ase.build import bulk
    from ase.calculators.emt import EMT
    from ase.md.langevin import Langevin
    from ase.md.velocitydistribution import MaxwellBoltzmannDistribution
    from ase import units

    # Build system and run MD
    cu = bulk("Cu", "fcc", a=3.615, cubic=True) * (3, 3, 3)
    cu.calc = EMT()
    MaxwellBoltzmannDistribution(cu, temperature_K=800)

    dyn = Langevin(cu, timestep=2.0 * units.fs, temperature_K=800,
                   friction=0.01 / units.fs, logfile=None)

    trajectory = []

    def save_frame():
        trajectory.append(cu.copy())
        trajectory[-1].calc = None  # don't keep calculator in trajectory

    dyn.attach(save_frame, interval=5)
    dyn.run(2000)

    print(f"Collected {len(trajectory)} trajectory frames")

    # Compute RDF
    r, g_r = compute_rdf(trajectory[-50:], species_pair=("Cu", "Cu"), rmax=8.0, nbins=80)

    # Compute MSD
    tau, msd = compute_msd(trajectory, species="Cu")

    # Compute RMSD
    rmsd_vals = compute_rmsd(trajectory)

    fig, axes = plt.subplots(1, 3, figsize=(15, 4))

    axes[0].plot(r, g_r, color="steelblue", lw=1.5)
    axes[0].axhline(1, color="gray", ls="--", lw=0.8, label="Ideal gas limit")
    axes[0].set_xlabel("r (Å)")
    axes[0].set_ylabel("g(r)")
    axes[0].set_title("Radial Distribution Function — Cu")
    axes[0].set_xlim(0, 8)
    axes[0].legend()

    valid = tau[1:] > 0
    axes[1].plot(tau[1:][valid], msd[1:][valid], color="darkorange", lw=1.5)
    axes[1].set_xlabel("Time lag (frames × 10 fs)")
    axes[1].set_ylabel("MSD (Ų)")
    axes[1].set_title("Mean Squared Displacement")

    axes[2].plot(np.arange(len(rmsd_vals)) * 10, rmsd_vals, color="tomato", lw=1)
    axes[2].set_xlabel("Time (fs)")
    axes[2].set_ylabel("RMSD (Å)")
    axes[2].set_title("RMSD from Initial Structure")

    plt.tight_layout()
    plt.show()

    return trajectory, r, g_r, msd


if __name__ == "__main__":
    trajectory_analysis_demo()

7. Complete Example A — CO Adsorption on Pt(111)

Compute the adsorption energy of CO on a Pt(111) surface using EMT.

import numpy as np
from ase.build import fcc111, molecule, add_adsorbate
from ase.calculators.emt import EMT
from ase.optimize import LBFGS
from ase.constraints import FixAtoms
import matplotlib.pyplot as plt


def co_adsorption_on_pt111(layers=4, vacuum=12.0, supercell=(3, 3)):
    """
    Calculate the adsorption energy of CO on Pt(111).

    E_ads = E(slab+CO) - E(slab) - E(CO)

    Positive E_ads means adsorption is favorable (exothermic).

    Adsorption sites tested: top, bridge, hollow-fcc, hollow-hcp
    """

    def build_clean_slab():
        slab = fcc111("Pt", size=(supercell[0], supercell[1], layers), vacuum=vacuum)
        # Fix bottom half of slab
        n_fix = len(slab) // 2
        slab.set_constraint(FixAtoms(indices=list(range(n_fix))))
        return slab

    def relax(atoms, fmax=0.05, label=""):
        atoms.calc = EMT()
        opt = LBFGS(atoms, logfile=None)
        opt.run(fmax=fmax, steps=300)
        e = atoms.get_potential_energy()
        print(f"  {label:25s}: E = {e:.4f} eV, steps = {opt.nsteps}")
        return atoms, e

    # 1. Relax clean slab
    print("Relaxing clean Pt(111) slab...")
    slab_clean, e_slab = relax(build_clean_slab(), label="Clean Pt(111)")

    # 2. Relax isolated CO molecule
    print("Relaxing CO molecule...")
    co = molecule("CO")
    co.cell = [15, 15, 15]
    co.center()
    co.pbc = True
    co_relaxed, e_co = relax(co, label="CO molecule")
    print(f"  CO bond length: {co_relaxed.get_distance(0, 1):.4f} Å")

    # 3. Test adsorption on top site
    adsorption_results = {}
    sites = {
        "top":     ("ontop",   (0, 0)),
        "bridge":  ("bridge",  (0, 0)),
        "fcc":     ("fcc",     (0, 0)),
        "hcp":     ("hcp",     (0, 0)),
    }

    print("\nCalculating adsorption energies on different sites:")
    for site_name, (site_type, offset) in sites.items():
        slab_co = build_clean_slab()
        slab_co.calc = EMT()

        co_mol = molecule("CO")
        try:
            add_adsorbate(slab_co, co_mol, height=1.8, position=site_type)
        except Exception:
            # Fallback: add CO manually on top of a surface atom
            surface_layer = [a for a in slab_co if a.tag == 1]
            if surface_layer:
                top_pos = slab_co[surface_layer[0].index].position[:2]
                add_adsorbate(slab_co, co_mol, height=1.8, position=top_pos)
            else:
                add_adsorbate(slab_co, co_mol, height=1.8)

        # Fix bottom layers
        n_fix = (len(slab_co) - len(co_mol)) // 2
        slab_co.set_constraint(FixAtoms(indices=list(range(n_fix))))

        slab_co_relaxed, e_slab_co = relax(slab_co, label=f"Pt(111)+CO/{site_name}")
        e_ads = e_slab + e_co - e_slab_co
        adsorption_results[site_name] = {
            "e_ads": e_ads,
            "e_total": e_slab_co,
        }

    print("\n" + "=" * 45)
    print("Adsorption Energies Summary:")
    print("=" * 45)
    for site, data in adsorption_results.items():
        print(f"  {site:8s}: E_ads = {data['e_ads']:+.4f} eV")

    best_site = max(adsorption_results, key=lambda s: adsorption_results[s]["e_ads"])
    print(f"\n  Most stable site: {best_site}")

    # Plot
    sites_list = list(adsorption_results.keys())
    e_ads_list = [adsorption_results[s]["e_ads"] for s in sites_list]

    fig, ax = plt.subplots(figsize=(7, 4))
    bars = ax.bar(sites_list, e_ads_list,
                  color=["green" if e > 0 else "tomato" for e in e_ads_list], alpha=0.8)
    ax.axhline(0, color="black", lw=0.8)
    ax.set_ylabel("E_ads (eV)")
    ax.set_title("CO Adsorption Energy on Pt(111) Sites")
    ax.bar_label(bars, fmt="%.3f", padding=3)
    plt.tight_layout()
    plt.show()

    return adsorption_results


if __name__ == "__main__":
    results = co_adsorption_on_pt111()

8. Complete Example B — Geometry Optimization and Vibrational Analysis

import numpy as np
from ase.build import molecule
from ase.calculators.emt import EMT
from ase.optimize import BFGS
from ase.vibrations import Vibrations
import matplotlib.pyplot as plt


def geometry_and_phonons(mol_name="H2O", outdir="/tmp/ase_vib"):
    """
    (b) Full workflow:
    1. Optimize geometry of a molecule
    2. Compute vibrational modes (numerical Hessian)
    3. Compute infrared intensities (if dipoles available)
    4. Plot vibrational spectrum

    Parameters
    ----------
    mol_name : str
        ASE molecule name, e.g. 'H2O', 'NH3', 'CH4'.
    outdir : str
        Directory to store vibrational calculation files.
    """
    import os
    os.makedirs(outdir, exist_ok=True)

    # 1. Build and optimize
    atoms = molecule(mol_name)
    atoms.cell = [15, 15, 15]
    atoms.center()
    atoms.pbc = False
    atoms.calc = EMT()

    print(f"{'='*50}")
    print(f"Molecule: {mol_name}, N_atoms = {len(atoms)}")
    print(f"{'='*50}")

    # Pre-optimization energy
    e0 = atoms.get_potential_energy()
    f0_max = np.abs(atoms.get_forces()).max()
    print(f"Initial: E = {e0:.4f} eV, |F|_max = {f0_max:.4f} eV/Å")

    opt = BFGS(atoms, logfile=None)
    opt.run(fmax=0.001, steps=1000)

    e_opt = atoms.get_potential_energy()
    f_opt_max = np.abs(atoms.get_forces()).max()
    print(f"Optimized: E = {e_opt:.4f} eV, |F|_max = {f_opt_max:.6f} eV/Å")
    print(f"Relaxation: ΔE = {e_opt - e0:.4f} eV, steps = {opt.nsteps}")

    # Print bond lengths and angles
    print("\nGeometry:")
    symbols = atoms.get_chemical_symbols()
    if mol_name == "H2O":
        print(f"  O-H1: {atoms.get_distance(0, 1):.4f} Å")
        print(f"  O-H2: {atoms.get_distance(0, 2):.4f} Å")
        print(f"  H-O-H: {atoms.get_angle(1, 0, 2):.2f}°")
    elif mol_name == "NH3":
        for i in range(1, 4):
            print(f"  N-H{i}: {atoms.get_distance(0, i):.4f} Å")

    # 2. Vibrational analysis
    print(f"\nComputing vibrational modes (numerical Hessian)...")
    vib = Vibrations(atoms, name=f"{outdir}/{mol_name}_vib", delta=0.01)
    vib.run()
    vib.summary(log="-")  # print summary to stdout

    # Get vibrational energies
    vib_energies = vib.get_energies()
    real_modes = [e for e in vib_energies if e.real > 1e-3 and abs(e.imag) < 1e-3]
    imaginary_modes = [e for e in vib_energies if abs(e.imag) > 1.0]

    print(f"\nVibrational frequencies (real modes):")
    for i, e in enumerate(real_modes):
        freq_cm1 = e.real * 8065.5  # eV → cm^-1
        freq_thz = e.real * 241.8   # eV → THz
        print(f"  Mode {i+1}: {freq_cm1:.1f} cm⁻¹  ({freq_thz:.2f} THz)")

    if imaginary_modes:
        print(f"  WARNING: {len(imaginary_modes)} imaginary mode(s) found.")

    # Zero-point energy
    zpe = vib.get_zero_point_energy()
    print(f"\nZero-point energy: {zpe:.4f} eV")

    # 3. Plot vibrational spectrum (Gaussian broadening)
    freq_range = np.linspace(0, 5000, 2000)  # cm^-1
    spectrum = np.zeros_like(freq_range)
    sigma = 30.0  # broadening in cm^-1

    for e in real_modes:
        freq_cm1 = e.real * 8065.5
        spectrum += np.exp(-0.5 * ((freq_range - freq_cm1) / sigma) ** 2)

    fig, axes = plt.subplots(2, 1, figsize=(10, 7))

    # Stick spectrum
    for e in real_modes:
        freq_cm1 = e.real * 8065.5
        axes[0].axvline(freq_cm1, ymin=0, ymax=1, color="steelblue", lw=2, alpha=0.8)
    axes[0].set_xlim(0, 5000)
    axes[0].set_ylabel("Intensity (arb.)")
    axes[0].set_title(f"{mol_name} Vibrational Frequencies (Stick Spectrum)")
    axes[0].set_xlabel("Wavenumber (cm⁻¹)")

    # Broadened spectrum
    axes[1].plot(freq_range, spectrum, color="darkorange", lw=1.5)
    axes[1].fill_between(freq_range, spectrum, alpha=0.3, color="darkorange")
    axes[1].set_xlim(0, 5000)
    axes[1].set_xlabel("Wavenumber (cm⁻¹)")
    axes[1].set_ylabel("Intensity (arb.)")
    axes[1].set_title(f"{mol_name} IR Spectrum (σ={sigma} cm⁻¹)")

    plt.tight_layout()
    plt.show()

    # Cleanup
    vib.clean()

    return atoms, vib_energies


if __name__ == "__main__":
    atoms_h2o, vib_h2o = geometry_and_phonons("H2O")
    atoms_nh3, vib_nh3 = geometry_and_phonons("NH3")

Quick Reference

TaskASE API
Build FCC bulkbulk("Cu", "fcc", a=3.615)
Build surface slabfcc111("Pt", size=(3,3,4), vacuum=10.0)
Build moleculemolecule("H2O")
Add adsorbateadd_adsorbate(slab, mol, height=1.8)
Fix atoms (constraint)FixAtoms(indices=[...])
Read structure fileread("file.cif")
Write structure filewrite("out.vasp", atoms, format="vasp")
Set EMT calculatoratoms.calc = EMT()
Get potential energyatoms.get_potential_energy()
Get forcesatoms.get_forces()
Optimize geometry (BFGS)BFGS(atoms); opt.run(fmax=0.01)
Optimize geometry (LBFGS)LBFGS(atoms); opt.run(fmax=0.05)
NVT Langevin MDLangevin(atoms, dt*units.fs, T, friction/units.fs)
NVE Verlet MDVelocityVerlet(atoms, dt*units.fs)
Maxwell-Boltzmann velocitiesMaxwellBoltzmannDistribution(atoms, temperature_K=T)
NEB transition stateNEB(images, climb=True); BFGS(neb).run(fmax=0.05)
Vibrational analysisVibrations(atoms); vib.run(); vib.summary()
Get bond distanceatoms.get_distance(i, j, mic=True)
Get bond angleatoms.get_angle(i, j, k)

Calculator Hierarchy

CalculatorUse caseAvailability
EMTFCC metals (quick testing)Built into ASE
GPAWDFT, PAW methodpip install gpaw
VASPDFT, plane wavesLicense required
CP2KDFT, mixed Gaussian/PWFree, open source
LAMMPSClassical MD, many potentialsFree, open source
Psi4 / ORCAQuantum chemistryFree/academic

Prerequisites

  • Python with ase installed (pip install ase); NEB/MD/vibrational examples additionally need numpy and matplotlib for plotting.
  • Examples run out of the box with the built-in EMT calculator and need no external quantum-chemistry code, license, or network access. Using GPAW/VASP/CP2K/LAMMPS/Psi4/ORCA as a calculator instead requires installing and, for VASP, licensing that code separately.

Limitations

  • EMT (the default calculator used throughout this skill) is an empirical potential parameterized only for a small set of FCC metals (Al, Cu, Ag, Au, Ni, Pd, Pt) and their alloys/surfaces. It is fast and dependency-free but not quantitatively accurate, and it should not be applied to other elements, molecules, semiconductors, or oxides — use it for workflow prototyping and testing, not for publishable energetics.
  • For quantitative energies, barriers, or vibrational frequencies, swap in a DFT or ab initio calculator (GPAW, VASP, ORCA, Psi4, etc.); ASE itself only provides the structure-building, optimization, and analysis machinery, not the underlying physics.
  • NEB and vibrational-analysis results are only as good as the underlying calculator and the chosen number of images/displacement step; always check convergence (forces, number of NEB images, vibrational mode visualization for spurious imaginary frequencies).

示例提示词

我想用ASE做晶体结构优化和分子动力学轨迹分析。

所属插件

化学面向化学研究:化学信息学、量子化学、分子模拟、反应检索与路线评审、谱学与质谱、催化剂检索与设计、电化学。

安装该插件会一并获得同领域的 32 个 Skill / MCP。

同插件的其他科研 Skill

常见问题

ASE原子模拟环境能做什么?

Builds and analyzes atomic structures with ASE: geometry optimization, NEB transition states, and MD trajectories. Use for setting up or analyzing atomistic simulations。

如何安装ASE原子模拟环境?

在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「ASE原子模拟环境」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。

ASE原子模拟环境需要哪些权限?

该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。

ASE原子模拟环境经过官方审核吗?

是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。