This project is a “digital restoration” of Aneesur Rahman’s seminal 1964 paper, Correlations in the Motion of Atoms in Liquid Argon. While the physics of liquid argon is a solved problem, the challenge lies in bridging the gap between 1960s mainframe constraints and 2025 software architecture.

I replicated the simulation using LAMMPS and built a Python analysis pipeline to process the trajectory data. The project demonstrates how modern tooling (uv, type hinting, vectorized NumPy) can transform academic “write-once” scripts into a reproducible research toolkit.

Features

The Analysis Pipeline

I architected a modular Python package (argon_sim) designed for performance and maintainability.

• Intelligent Caching System: MD analysis is compute-intensive ($O(N^2)$). I implemented a decorator-based caching layer (@cached_computation) that hashes source file modification times and function arguments. This ensures expensive calculations (like RDF or Van Hove correlations) are only re-run when the underlying trajectory or parameters actually change.
• Vectorization & Optimization: To handle the $N^2$ complexity of pair-wise interactions without C++ extensions, I utilized NumPy broadcasting. For example, the Mean Square Displacement (MSD) calculation is fully vectorized, with a fallback “chunked” implementation to handle memory overflows on smaller machines.
• Modern Python Tooling:
  • Dependency Management: Used uv for deterministic environment locking (sub-second resolution).
  • Type Safety: Fully type-hinted codebase for static analysis compliance.
  • Automation: A Makefile abstracts the workflow (simulation → analysis → figure generation) into single commands (e.g., make figure-5).

The Simulation Strategy

I used LAMMPS for the MD engine but strictly adhered to Rahman’s physical parameters while modernizing the stability mechanisms.

• Integration: Replaced Rahman’s predictor-corrector method with the modern standard Velocity Verlet algorithm (2 fs timestep).
• Equilibration: I implemented a 1 ns NVT equilibration phase (500,000 steps at the 2 fs timestep) to properly melt the FCC crystal structure before the NVE production run.
• Intellectual Honesty: The in.argon script explicitly documents every deviation from the original methodology (e.g., energy minimization) and the justification for ensuring numerical stability.

Usage

The project uses a Makefile to automate the workflow. Run make all to execute the LAMMPS simulation and generate all analysis figures.

Results

The replication achieved high quantitative agreement with the historical data, validating both the simulation parameters and the custom analysis code.

Visual Replication

I used Matplotlib to digitally recreate Rahman’s hand-drawn plots, confirming signatures like the negative region in the Velocity Autocorrelation Function (VACF), which provided the first evidence of the “cage effect” in simple liquids.

Challenges & Learnings

• Unit Hell: Rahman’s paper uses a mix of reduced units and CGS. Mapping these to LAMMPS’s real units required a dedicated constants.py module and rigorous unit testing to prevent dimensional errors.
• Fourier Transforms: Calculating the Structure Factor $S(k)$ from $g(r)$ required implementing a manual 3D Fourier transform for spherical symmetry, as standard FFT packages do not account for the radial shell integration implicit in liquid structure analysis.
• Code as a Liability: Early in the project, I realized that re-running analysis scripts was becoming a bottleneck. This drove the decision to build the caching infrastructure, reinforcing the lesson that investing in developer tooling pays off even in small-scale scientific projects.

Related Work

The full methodology and physics are documented in the companion blog post:

• Replicating Rahman’s 1964 Liquid Argon Simulation

The physics of liquid argon is a solved problem. We know the answer.

So, why replicate it in 2025? To apply modern engineering standards to legacy science.

This project served as an exercise in software archaeology: taking a vintage scientific workflow and rebuilding it with a modular Python analysis pipeline. I wanted to see if I could replace Rahman’s “write-once” Fortran mentality with modern reproducibility, type safety, and intelligent caching.

The full source code is available on GitHub. The complete project overview, including analysis results and pipeline architecture, is on the Rahman 1964 Replication project page.

Engineering the Pipeline

The most interesting part of this project isn’t the simulation engine (LAMMPS handles that); it’s the architecture of the analysis suite. MD analysis is computationally expensive ($O(N^2)$), and iterating on plots can be painfully slow if you re-compute trajectory data every time.

Why bother? Don’t modern MD packages come with analysis tools? Well, some say that writing is thinking. Sometimes getting into the weeds of how an algorithm works or an analysis is performed, you gain insights and a deeper understanding that might be obscured by a plug-and-play tool.

Intelligent Caching

I built the argon_sim package with a decorator-based caching layer. The system hashes the source file’s modification time and the function’s arguments to avoid re-calculating the Radial Distribution Function (RDF) or Van Hove correlations on every script run.

@cached_computation("gr")
def compute_radial_distribution(filename: str, dr: float = 0.05):
    # ... expensive O(N^2) distance calculations ...
    return r_values, g_r, density

If I tweak a plot axis, the script runs instantly, loading pre-computed arrays from disk instead of re-running the $O(N^2)$ computation. If I change the simulation trajectory, the cache invalidates automatically.

Vectorization & Memory Management

Rahman likely relied on nested loops. Python is too slow for that. I utilized NumPy broadcasting to vectorize the calculation of atomic displacements.

However, calculating an $864 \times 864$ distance matrix for 5,000 frames consumes significant RAM. I implemented a chunked MSD (Mean Square Displacement) algorithm that processes the trajectory in blocks, balancing vectorization speed with memory constraints. The chunking trades some vectorization speed for a bounded memory footprint, so the analysis is not capped by holding the full distance matrix in RAM.

Reproducibility as a Feature

Academic code is notorious for “it works on my machine.” To combat this, I used uv for dependency management, locking the exact environment state. The entire workflow (from simulation to final figure generation) is abstracted into a Makefile.

# One command to run the physics, analyze data, and generate plots
make workflow

The Simulation: 1964 vs. 2025

I preserved Rahman’s physical parameters exactly to ensure a fair comparison:

• System: 864 Argon atoms
• Potential: Lennard-Jones ($\sigma = 3.4$ Å, $\epsilon/k_B = 120$ K)
• Target: 94.4 K, 1.374 g/cm³

However, I modernized the numerical methods to ensure stability:

The production run lasted 10 ps in the NVE ensemble, generating 5,001 frames. Temperature remained within 1% of target with an RMS fluctuation of 0.0165.

Validation Results

The replication was quantitatively successful. The analysis pipeline faithfully reproduced every key signature of liquid argon.

The Cage Effect

This is the paper’s crown jewel. In a gas, velocity correlations decay exponentially. In a liquid, Rahman discovered that atoms get trapped by their neighbors and bounce back, causing the correlation to go negative.

My simulation captures this minimum at -0.083, matching Rahman’s observation. The Fourier transform of this data (the frequency spectrum) reveals a peak at $\beta \approx 0.25$, physically representing the frequency of atomic collisions within the cage.

Structural Fingerprints

The Radial Distribution Function $g(r)$ and its Fourier transform, the Structure Factor $S(k)$, are the “fingerprints” of a liquid’s structure.

The agreement here is striking. My first peak appeared at 3.82 Å (Rahman: 3.7 Å). The slight discrepancy is likely due to my improved equilibration method, which allowed the system to relax into a more natural liquid state than Rahman’s 1960s hardware allowed.

Diffusion and Non-Gaussian Behavior

By calculating the Mean Square Displacement (MSD), I derived a diffusion coefficient of $D = 2.47 \times 10^{-5}$ cm²/s, which deviates only 2% from Rahman’s reported $2.43 \times 10^{-5}$.

More interestingly, I reproduced the “Non-Gaussian” parameters. Standard diffusion assumes a Gaussian distribution of displacements. Rahman found (and I confirmed) that liquid atoms deviate from this. They exhibit “jump” and “wait” dynamics, a behavior that standard Brownian motion models fail to capture.

Advanced Analysis: Van Hove Functions

Rahman also explored advanced properties like the Van Hove correlation function $G(r,t)$, which describes how liquid structure evolves over time.

At 1.0 ps, the structure remains well-defined with clear shells. By 2.5 ps, it becomes increasingly diffuse. Rahman compared this evolution to theoretical predictions (the Vineyard approximation) and found that theory predicted overly rapid structural decay. My results confirm this finding.

System Validation

Before analyzing physics, basic sanity checks confirmed proper thermal equilibrium.

Mean temperature was 94.73 K (0.33 K off target) with a standard deviation of 1.56 K.

The velocity distribution from 12.9 million velocity components produces a clean Maxwell-Boltzmann distribution, as expected for thermal equilibrium. The distribution widths at various heights closely match Rahman’s results: 1.77, 2.48, and 3.56 compared to his 1.77, 2.52, and 3.52.

Conclusion

Replicating a 60-year-old paper might seem like a solved puzzle, but it teaches a valuable lesson in computational science. Rahman relied on brilliance and raw mathematical intuition because he lacked compute power. Today, pairing modern compute with disciplined software practices makes the same result reproducible and auditable.

Applying modern software engineering (modular architecture, caching, and automated workflows) to classical physics reproduces the past and builds a foundation that makes the next discovery easier, faster, and more reliable.

The quantitative agreement is striking: diffusion coefficients within 2%, structural peaks within 0.1 Å, velocity distributions matching to three significant figures. This level of reproducibility, achieved with completely different hardware and software, validates something fundamental: Rahman’s physical model was remarkably sound, and his computational methodology was scientifically rigorous despite 1960s constraints.

The cage effect, velocity correlations, and structural evolution are fundamental characteristics of how matter behaves at the atomic scale, as relevant today as they were six decades ago.

Details on the simulation can be found in the Liquid Argon: LAMMPS Simulation post.

Details on the simulation can be found in the LAMMPS Tutorial: Copper and Platinum Adatom Diffusion post and the Automated Adatom Diffusion Workflow project page.

Understanding how individual atoms move on crystal surfaces is fundamental to materials science, catalysis, and nanotechnology. This atomic-scale motion, called adatom diffusion, drives processes like thin film growth and surface chemical reactions.

While learning molecular dynamics simulations for my graduate work, I discovered these simulations generate valuable training data for machine learning models. This tutorial walks through simulating copper adatom diffusion on a Cu(100) surface using LAMMPS, building on Eric N. Hahn’s excellent adatom tutorial.

What you’ll learn:

• Setting up LAMMPS for surface diffusion simulations
• Understanding simulation parameters and their impact
• Visualizing results with Ovito
• Analyzing trajectory data for ML applications
• Connecting simulation data to machine learning workflows

In this tutorial, we will explore both Copper (Cu) and Platinum (Pt) to show how atomic properties affect diffusion behavior, generating data for training element-aware ML models.

Prerequisites

Before starting this tutorial, you’ll need:

• LAMMPS with EAM potential support (version 2020 or later recommended)
• Python 3.x with matplotlib for analysis scripts
• Ovito (free version) for trajectory visualization
• Cu01.eam.alloy potential file from the NIST repository
• Basic familiarity with molecular dynamics concepts (atoms, forces, timesteps)

Understanding Adatoms and Surface Diffusion

What is an Adatom?

An adatom (adsorbed atom) sits on a crystal surface but isn’t incorporated into the bulk structure. Adatoms have fewer bonds than fully coordinated bulk atoms, making them highly mobile and reactive.

Why Study Adatom Diffusion?

Adatom diffusion is important for several technological processes:

• Thin film growth: Adatoms are the building blocks of deposited films
• Catalysis: Many reactions happen at these mobile surface atoms
• Corrosion: How surface atoms move affects material degradation
• Self-assembly: Adatom movement enables formation of ordered structures

From a machine learning perspective, adatom diffusion is an ideal test case because:

• Well-understood physics provides ground truth for validation
• Small system size enables extensive simulation
• Behavior varies significantly with temperature and atomic species
• Systematic data generation across different conditions

Why Cu(100)?

Cu(100) surfaces are well-studied in literature, making them excellent benchmarks. The face-centered cubic (fcc) structure creates clear diffusion pathways, and copper’s moderate binding energy lets us observe diffusion at reasonable temperatures without extreme computational demands.

Simulation Overview

Before diving into the code details, let’s understand the simulation design:

Key Simulation Parameters

Simulation Strategy

The approach uses a thermal gradient setup:

• Bottom layers: Fixed to represent bulk crystal
• Middle layers: Heated to 850 K for thermal energy
• Top layers and adatom: Equilibrate to $\sim 600$ K for diffusion
• This lets thermal energy propagate up from the heated reservoir to the free surface where the adatom diffuses

The complete LAMMPS script implementing this approach:

### Original Created by Eric N. Hahn  ###
### ericnhahn@gmail.com ###

### Modifications by Hunter Heidenreich, CSE lab (Harvard, 2023)
### hheidenreich@g.harvard.edu
### 2023-09-01

### Simulating adatoms ###
### Version 0.2 ###


units metal
dimension 3
boundary p p s
atom_style atomic

lattice fcc 3.614
variable cubel equal 4
variable fixer1 equal "v_cubel+2"
variable fixer2 equal "v_cubel+1.49"
region  box block -${cubel} ${cubel} -${cubel} ${cubel} -${fixer1} 1 units lattice
region cbox block -${cubel} ${cubel} -${cubel} ${cubel} -${fixer1} 0 units lattice
create_box 1 box
create_atoms 1 region cbox
create_atoms 1 single -0.5 0 0.5 units lattice
region hold block INF INF INF INF -${fixer1} -${fixer2} units lattice
region temp block INF INF INF INF -${fixer2} -${cubel} units lattice
group hold region hold
group temp region temp

pair_style eam/alloy
pair_coeff * * Cu01.eam.alloy Cu

timestep        0.005
compute         new all temp
velocity        temp create 600 12345
fix heater temp temp/rescale 1 850 850 5 1
fix nve all nve
fix freeze hold setforce 0 0 0

variable e     equal pe
variable k     equal ke
variable t     equal etotal
variable T     equal temp
fix energy all ave/time 1 50 50 v_k v_e v_t v_T file energy_avg.txt

minimize 1.0e-4 1.0e-6 1000 10000

dump eve all custom 5 dump.lammpstrj id type xu yu zu   # fx fy fz  # uncomment for forces
dump_modify eve sort id

thermo 50
run 100000  # 100_000 * 5 fs = 500 ps

Line-by-Line Breakdown

Let’s examine each part of the LAMMPS script:

Simulation Setup

Units

units metal

Sets simulation units to “metal” units (a standard choice for metallic systems). Key conversions: length in $\text{\AA}$, energy in eV, time in ps. Full details in the LAMMPS documentation.

dimension 3

Sets 3D simulation.

boundary p p s

Boundary conditions: periodic in x,y (infinite surface) and shrink-wrapped in z (finite surface height). This allows the adatom to potentially leave the surface if needed.

atom_style atomic

Uses “atomic” style, atoms as point masses without internal structure. Standard for metallic systems.

Lattice

lattice fcc 3.614

Defines face-centered cubic lattice with experimental Cu lattice constant ($3.614 \text{ \AA}$).

variable cubel equal 4
variable fixer1 equal "v_cubel+2"
variable fixer2 equal "v_cubel+1.49"

Define variables for simulation box dimensions. cubel=4 sets system size, while fixer1 and fixer2 define the frozen and heated regions.

region  box block -${cubel} ${cubel} -${cubel} ${cubel} -${fixer1} 1 units lattice
region cbox block -${cubel} ${cubel} -${cubel} ${cubel} -${fixer1} 0 units lattice

Define regions: box for the entire simulation volume and cbox for crystal creation (excludes the surface layer where we’ll place the adatom).

create_box 1 box
create_atoms 1 region cbox
create_atoms 1 single -0.5 0 0.5 units lattice

Create simulation box, populate with Cu atoms, then add single adatom at specified position.

region hold block INF INF INF INF -${fixer1} -${fixer2} units lattice
region temp block INF INF INF INF -${fixer2} -${cubel} units lattice
group hold region hold
group temp region temp

Define atom groups: hold (frozen bottom layers) and temp (heated middle layers for thermal energy).

pair_style eam/alloy
pair_coeff * * Cu01.eam.alloy Cu

Use Embedded Atom Method (EAM) potential for metallic bonding. The Cu01.eam.alloy potential from Mishin et al. is available from the NIST repository.

timestep        0.005

5 femtosecond timestep (small enough for numerical stability).

Initial Conditions

velocity        temp create 600 12345

Initialize velocities for 600 K temperature using random seed 12345.

fix heater temp temp/rescale 1 850 850 5 1
fix nve all nve
fix freeze hold setforce 0 0 0

Three fixes control dynamics:

• heater: Maintains 850 K in middle layers
• nve: Velocity Verlet integration for all atoms
• freeze: Sets forces to zero for bottom atoms

variable e     equal pe
variable k     equal ke
variable t     equal etotal
variable T     equal temp
fix energy all ave/time 1 50 50 v_k v_e v_t v_T file energy_avg.txt

Track energies and temperature, averaging every 50 timesteps and writing to file.

Execution

Minimization

minimize 1.0e-4 1.0e-6 1000 10000

Relax initial structure. Should converge quickly, indicating the system is already well-optimized.

Output Setup

dump eve all custom 5 dump.lammpstrj id type xu yu zu   # fx fy fz  # uncomment for forces
dump_modify eve sort id

Write atomic positions every 5 timesteps, sorted by atom ID. Uncomment force components if needed for analysis.

Production Run

thermo 50
run 100000  # 100_000 * 5 fs = 500 ps

Run simulation for 500 ps with thermo output every 50 steps.

Visualization and Analysis

Visualize results using Ovito, a free atomistic visualization tool:

1. Open the trajectory file in Ovito
2. Color atoms by z-coordinate
3. Restrict height range to $0\text{-}2 \text{ \AA}$ for surface focus
4. Animate to observe diffusion events

Analysis Results

The simulation generates rich data for machine learning applications:

Energy Analysis

Energy fluctuations reveal thermal motion patterns:

Skipping the first 30 logged data points (each averaged over 50 timesteps, so the first ~1500 timesteps / 7.5 ps of equilibration), these fluctuations enable:

• Anomaly detection: Identifying unusual diffusion events
• Temperature prediction: Estimating local temperature from atomic motion
• Stability analysis: Detecting equilibrium states

Trajectory Analysis

Adatom motion reveals diffusion mechanisms:

This data enables:

• Path prediction: Training models for future position forecasting
• Diffusion coefficient estimation: Learning temperature-mobility relationships
• Transition state identification: Detecting hops between stable sites

Z-coordinate data shows exchange events where the adatom swaps with surface atoms (crucial for surface chemistry understanding). This enables:

• Event classification: Distinguishing diffusion vs. exchange mechanisms
• Activation barrier estimation: Learning energy landscapes from fluctuations
• Surface coordination analysis: Correlating height with local environment

Machine Learning Applications

This simulation produces multiple data types for ML training:

1. Coordinate trajectories: Neural network potential inputs or graph neural network features
2. Energy time series: Regression model features for system property prediction
3. Event annotations: Supervised learning labels for diffusion mechanism classification
4. Environmental descriptors: Local atomic arrangement features

Systematic MD simulations generate large, labeled datasets across varied conditions.

Extending to Platinum: Mass and Bonding Effects

To understand how different elements behave, we can extend this framework to platinum (Pt). Platinum’s higher atomic mass and stronger metallic bonding create notably different diffusion behavior, providing comparative data for machine learning.

Key Differences from Copper

Modifying the LAMMPS Script

The platinum simulation uses the exact same framework as the copper case, with three simple element-specific modifications:

1. Lattice constant: Change lattice fcc 3.614 to lattice fcc 3.96
2. Potential file: Change Cu01.eam.alloy to Pt_Zhou04.eam.alloy (available from the NIST repository)
3. Element specification: Change Cu to Pt in the pair_coeff line

These simple changes capture the essential physics differences between elements while maintaining the same simulation protocol, which is ideal for generating comparative datasets for ML training.

Expected Behavior vs. Copper

When you run the analysis scripts on the platinum trajectory, you will observe:

• Slower motion: Heavier atoms move more slowly at the same temperature. Platinum’s ~3x greater mass reduces diffusion rates.
• Higher energy barriers: Stronger metallic bonding creates deeper potential wells, requiring more thermal energy for diffusion hops.
• Different pathways: The larger lattice constant changes the energy landscape, potentially favoring different diffusion mechanisms.

Comparing Cu and Pt trajectories enables training element-aware models that account for atomic mass effects, binding strengths, and temperature scaling across different metals.

Code and Data

The complete simulation scripts and analysis tools are available for reproducibility:

Energy Analysis Script

# Hunter Heidenreich, 2023
# Plots the energy of a simulation over time.

import matplotlib.pyplot as plt
from argparse import ArgumentParser

if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('--input', type=str, required=True)
    parser.add_argument('--output', type=str, required=True)
    parser.add_argument('--skip', type=int, default=1)
    args = parser.parse_args()

    # Parse energy data
    data = {'ts': [], 'kes': [], 'pes': [], 'tes': [], 'Ts': []}
    with open(args.input, 'r') as f:
        for line in f:
            if line.startswith('#') or not line.strip():
                continue
            t, v_k, v_e, v_t, v_T = map(float, line.split())
            data['ts'].append(t)
            data['kes'].append(v_k)
            data['pes'].append(v_e)
            data['tes'].append(v_t)
            data['Ts'].append(v_T)

    # Skip initial equilibration
    for key in data:
        data[key] = data[key][args.skip:]

    # Create subplots
    fig, axs = plt.subplots(2, 2, figsize=(16, 12))

    plots = [('Kinetic Energy', 'kes'), ('Potential Energy', 'pes'),
             ('Total Energy', 'tes'), ('Temperature', 'Ts')]

    for ax, (title, key) in zip(axs.flat, plots):
        ax.plot(data['ts'], data[key])
        ax.set_xlabel('TimeStep')
        ax.set_ylabel(title)
        ax.set_title(title)

    plt.tight_layout()
    plt.savefig(args.output, dpi=300, bbox_inches='tight')

Trajectory Analysis Script

# Hunter Heidenreich, 2023
# Plots the coordinates of the adatom.

import matplotlib.pyplot as plt
from argparse import ArgumentParser

if __name__ == '__main__':
    parser = ArgumentParser()
    parser.add_argument('--input', type=str, required=True)
    parser.add_argument('--output', type=str, required=True)
    parser.add_argument('--id', type=int, default=1665,
                       help='Atom ID to track (the adatom is the last created atom)')
    parser.add_argument('--do_z', action='store_true',
                       help='Plot z-coordinate instead of xy scatter')
    args = parser.parse_args()

    coords = {'x': [], 'y': [], 'z': []}
    with open(args.input, 'r') as f:
        for line in f:
            if line.startswith(f'{args.id} '):
                x, y, z = map(float, line.split()[2:5])
                coords['x'].append(x)
                coords['y'].append(y)
                coords['z'].append(z)

    plt.figure(figsize=(10, 8))
    if args.do_z:
        plt.plot(range(len(coords['z'])), coords['z'], 'b-', linewidth=1)
        plt.xlabel('Simulation Step')
        plt.ylabel('Z Coordinate (Å)')
        plt.title(f'Height vs. Time for Adatom {args.id}')
        plt.grid(True, alpha=0.3)
    else:
        plt.scatter(coords['x'], coords['y'], s=1, alpha=0.7, c='red')
        plt.xlabel('X Coordinate (Å)')
        plt.ylabel('Y Coordinate (Å)')
        plt.title(f'XY Trajectory for Adatom {args.id}')
        plt.axis('equal')
        plt.grid(True, alpha=0.3)

    plt.savefig(args.output, dpi=300, bbox_inches='tight')

Summary and Next Steps

This tutorial demonstrates how molecular dynamics generates valuable ML training data for materials science. Adatom diffusion provides an ideal starting point because it:

• Has interpretable physics: Well-understood mechanisms enable ML validation
• Shows diverse behaviors: Temperature-dependent dynamics create rich datasets
• Scales efficiently: Small systems allow extensive parameter exploration
• Connects to applications: Direct relevance to catalysis and surface engineering

What’s Next

Future posts will extend this framework:

1. Mixed-metal surfaces: Alloy effects on diffusion pathways
2. Stepped surfaces: How defects alter atomic mobility
3. ML implementation: Training neural networks on simulation data

Broader Applications

These simulation techniques enable various ML applications:

• Neural network potentials: Replacing expensive quantum calculations with trained models
• Rare event sampling: ML-enhanced diffusion pathway identification
• Catalyst design: Predicting surface modification effects on reactivity
• Materials discovery: Screening alloy compositions for desired properties

Getting Started

To reproduce these simulations:

1. Install LAMMPS with EAM potential support
2. Download Cu01.eam.alloy from the NIST repository and place in your working directory
3. Save the LAMMPS script as adatom_cu.lammps and run:

   lammps -in adatom_cu.lammps
   

4. Analyze the results with the Python scripts:

   python plot_energy.py --input energy_avg.txt --output energy.png --skip 30
   python plot_trajectory.py --input dump.lammpstrj --output trajectory_xy.png
   python plot_trajectory.py --input dump.lammpstrj --output trajectory_z.png --do_z
   

5. Visualize in Ovito by opening dump.lammpstrj
6. Experiment with different temperatures, orientations, or elements

The full project, including the simulation architecture and automated analysis pipeline, is documented on the Automated Adatom Diffusion Workflow project page.

Questions about the simulation setup or interested in applying these techniques to your research? Feel free to reach out. I’m always happy to discuss molecular dynamics and machine learning applications.

References

• LAMMPS
• Ovito
• NIST Interatomic Potentials Repository
• Mishin et al.

Details on the simulation can be found in the Cu Adatom Diffusion on Cu(100) post and the Automated Adatom Diffusion Workflow project page.

This project provides an “input-to-analysis” workflow for simulating adatom diffusion on FCC metal surfaces. It demonstrates how to set up surface diffusion simulations in LAMMPS, manage EAM potentials, and parse trajectory data into energy and trajectory plots using Python. The LAMMPS input scripts are adapted from Eric N. Hahn’s adatom tutorial; the Python analysis layer (plot_energy.py, plot_xy.py) is my own, written while in CSElab (Harvard, 2023).

The workflow covers two material systems (Copper (Cu) and Platinum (Pt)) providing comparative datasets that highlight how atomic mass and bonding strength affect surface dynamics.

Features

Simulation Architecture

The project separates simulation logic from analysis code:

Each directory contains:

• LAMMPS input scripts (.in files) defining the physics
• EAM potential files for metallic bonding (the Cu potential is committed; the Pt potential must be downloaded separately from the NIST Interatomic Potentials Repository, so the Pt system does not run as-checked-out)
• Python analysis scripts for trajectory and energy parsing

Key Features

• EAM Potentials: Uses Embedded Atom Method alloy potentials to accurately model metallic bonding and surface energies, providing accuracy beyond simple Lennard-Jones potentials
• Automated Analysis: Python pipeline (plot_energy.py, plot_xy.py) that parses raw thermodynamic logs and trajectory dumps to generate “health check” dashboards
• Workflow Orchestration: Demonstrates the “Input → Simulation → Analysis” loop, automating the transition from raw .lammpstrj files to publication-ready plots
• Kokkos Support: Includes Kokkos execution commands for GPU/multi-threaded runs

Simulation Parameters

Usage

The repository includes LAMMPS input scripts and Python analysis scripts. Run the LAMMPS scripts to generate trajectory data, then use the Python scripts to visualize the results.

Results

This workflow is documented in detail in companion blog posts:

• LAMMPS Tutorial: Copper and Platinum Adatom Diffusion - Complete setup walkthrough with line-by-line script explanation and comparison of how heavier atoms behave differently on surfaces