Parallel athermal quasistatic deformation stepping of molecular systems

This paper introduces a novel parallel athermal quasistatic deformation scheme that utilizes a two-level stepping approach to significantly accelerate the computation of molecular system trajectories, achieving speed-ups between 2.02 and 6.33 times while maintaining simulation accuracy.

The Gist

Imagine you are trying to navigate a hiker through a vast, foggy mountain range to find the lowest valley (the most stable state) while slowly pushing the entire landscape sideways. This is essentially what scientists do when they simulate how materials, like glass or metal, deform under stress at the atomic level.

The paper by Reihn, Bamer, and Stamm introduces a new, faster way to do this navigation. Here is the breakdown using simple analogies:

The Problem: The Slow Hiker

In traditional computer simulations (called "Athermal Quasistatic" or AQS), scientists simulate a material by taking tiny steps.

1. Push: They push the atoms slightly (like tilting the mountain).
2. Settle: The atoms immediately scramble to find a new, comfortable resting spot (a local valley).
3. Repeat: They push again, and the atoms scramble again.

The problem is that this is a one-person job. The computer must finish the "settle" phase completely before it can take the next "push" step. If the material is complex, this "settle" phase takes a long time, making the whole simulation incredibly slow.

The Solution: The Scout Team

The authors propose a two-level parallel stepping scheme. Think of this not as one hiker, but as a team of hikers working together, using a "Predictor-Corrector" strategy.

Level 1: The Fast Scouts (The Prediction)
Imagine you have a team of $P$ scouts (computer threads). Instead of waiting for the slow hiker to settle, the team leader quickly throws a map forward to all scouts at once.

• The leader says, "Let's guess where we will be if we push the mountain 10 times further."
• The scouts instantly calculate these "guess" positions. This is very fast because it's just a simple math calculation (like sliding a piece of paper) without doing the heavy lifting of finding the valley yet.
• These guesses act as starting points for the next phase.

Level 2: The Heavy Lifters (The Correction)
Now, all the scouts work simultaneously (in parallel) on their assigned sections of the mountain.

• Scout 1 takes the first guess and does the heavy work: finding the true valley for that spot.
• Scout 2 takes the second guess and finds their valley.
• They all do this at the same time, rather than waiting for one to finish before the next starts.

The Checkpoint: The "Are We Still Together?" Test
This is the clever part. Because the mountain is tricky, a scout might guess wrong and end up in a different valley than the one the slow hiker would have found.

• Once the scouts finish their heavy lifting, they meet back at the leader.
• They compare their results. Did Scout 2 end up in the same valley that the "slow hiker" (the standard method) would have found?
• If Yes: Great! The team accepts all the work done. They have successfully skipped ahead many steps in a fraction of the time.
• If No: One scout took a wrong turn. The team must discard the work of that scout and everyone who followed them, go back to the last known safe spot, and try again.

The Results: Speed Without Sacrificing Accuracy

The authors tested this on 1,000 different "mountain" scenarios (simulations of glass).

• Speed: By using 4 to 32 computer processors (threads) at once, they made the simulation 2 to 6 times faster on average.
• Accuracy: Crucially, they didn't cheat. The final result is exactly the same as if they had done the slow, one-person method. They didn't skip steps; they just found a way to do the hard work in parallel and fixed any mistakes instantly.

Why It's Not Perfectly Linear

You might think, "If I use 32 scouts, I should be 32 times faster." The paper explains why this isn't quite true:

• The "Wait" Factor: Some parts of the mountain are harder to navigate than others. If one scout gets stuck in a very deep, complex valley, the others have to wait for them to finish before the team can move on.
• The "Wrong Turn" Factor: If a scout guesses too far ahead, they might land in a totally different valley. If this happens, the team has to throw away the work of the scouts who went further and start over. The more scouts you have, the higher the chance someone might take a wrong turn, which wastes some time.

Summary

The paper presents a method to simulate how materials deform by using a team of computers to guess ahead, do the hard work simultaneously, and then double-check their answers. If the answers match, they move forward fast. If they don't, they backtrack and try again. This allows them to solve complex material problems 2 to 6 times faster than before, without losing any precision.

Technical Summary

1. Problem Statement

Molecular simulations are essential for understanding the structure-property relationships of materials, particularly in phenomena like fracture and inelastic deformation. However, these simulations face two primary bottlenecks:

• Time Scale Limitations: Standard molecular dynamics (MD) requires femtosecond time steps to resolve atomic vibrations, making it impossible to simulate slow, macroscopic deformation processes (quasistatic loading) within reasonable computational time.
• Computational Cost of AQS: The Athermal Quasistatic (AQS) method (or zero-temperature method) overcomes the time-step limitation by assuming overdamped conditions where the system always resides in a local minimum of the Potential Energy Surface (PES). However, AQS requires a sequential process: apply an affine deformation, then perform a computationally expensive energy minimization to find the new equilibrium. Because each step depends on the result of the previous one, this process is inherently serial and slow, especially for large systems or long deformation histories.

Existing parallelization strategies (e.g., force decomposition) accelerate individual steps but do not parallelize the sequence of deformation steps required to trace the solution trajectory.

2. Methodology

The authors propose a two-level parallel stepping scheme inspired by the Parareal algorithm for ordinary differential equations. The method utilizes a predictor-corrector framework to parallelize the deformation history across $P$ threads.

Core Algorithm: Two-Level Stepping

The algorithm divides the deformation process into a coarse "Level I" and a fine "Level II":

1. Level I (Prediction / Coarse Stepping):

   • Starting from a verified correct configuration $r^*$, the algorithm performs $P$ coarse affine deformations with a large step size $\Delta\gamma_c = K \cdot \Delta\gamma$ (where $K$ is an integer).
   • These steps involve simple matrix-vector multiplications ($F(i\Delta\gamma_c)$) to generate $P$ intermediate "guess" configurations ($r^c_{iK}$).
   • Crucially, no energy minimization is performed at this stage. These guesses are merely affine transformations of the reference state.

2. Level II (Correction / Fine Stepping):

   • Each of the $P$ threads takes one of the Level I guesses and performs a fine-grained AQS sequence consisting of $K$ small steps ($\Delta\gamma$).
   • For each thread $i$, the process involves:
     • Minimizing the Level I guess to find the local inherent structure.
     • Performing $K$ sequential AQS steps (affine deformation + minimization) to generate a trajectory segment.
   • This is done in parallel across all threads.

3. Equality Checking (Verification):

   • After Level II completes, the algorithm performs a sequential verification to check if the parallel predictions were correct.
   • It compares the outgoing configuration from thread $i-1$ (the result of $K$ fine steps) with the incoming configuration (the minimized Level I guess) of thread $i$ at the same strain state.
   • Condition for Acceptance: If both configurations reside in the same "basin of attraction" (i.e., they are equivalent local minima), the trajectory is valid.
   • Condition for Rejection: If the configurations differ (indicating the coarse affine step crossed a local energy maximum and landed in a different basin), the prediction is rejected. The algorithm discards all subsequent steps from that point and restarts the iteration from the last verified configuration.

Mathematical Formalism

The method relies on the definition of the basin of attraction $\Omega_{r_\infty, \gamma}$. Two configurations are considered equal if they converge to the same limit under gradient flow. The algorithm ensures that the final trajectory is numerically identical to a standard sequential AQS simulation.

3. Key Contributions

• Novel Parallelization Strategy: The first method to parallelize the temporal sequence of AQS deformation steps, rather than just the spatial force calculations within a single step.
• Predictor-Corrector Framework: A robust mechanism that uses cheap affine predictions to seed expensive minimization tasks, with a rigorous check to ensure physical correctness.
• Preservation of Accuracy: Unlike approximate methods, this approach guarantees that the final solution trajectory is exactly equivalent to the conventional sequential AQS method.
• Handling Non-Convexity: The method explicitly addresses the non-convex nature of the PES, where large affine steps might push the system over energy barriers into incorrect basins, and provides a mechanism to detect and correct this.

4. Results

The authors tested the method on 1,000 binary Lennard-Jones glass samples (400 atoms each) subjected to simple shear deformation.

• Speed-Up Performance:
  • The method achieved consistent computational speed-ups compared to sequential AQS.
  • Average Speed-Up: Ranged from 2.02x (with 4 threads, $K=1$) to 6.33x (with 32 threads, $K=10$).
  • Optimal Parameters: The best performance was observed with $P=32$ threads and a coarse step multiplier $K=10$.
• Scaling Behavior:
  • Scaling was not linear with the number of threads ($P$). As $P$ increased, the likelihood of "miss-predictions" (crossing energy barriers during the coarse affine step) increased, leading to more rejections and wasted computation.
  • Similarly, very large $K$ values increased the risk of crossing barriers, while very small $K$ values introduced excessive overhead from frequent minimizations.
• Load Balancing: The authors noted that load balancing is imperfect because the number of conjugate gradient (CG) minimization steps required varies stochastically between threads. The system must wait for the slowest thread, and if an early thread fails the equality check, subsequent threads' work is discarded.

5. Significance and Future Outlook

• Efficiency: The method offers a powerful tool for simulating slow, athermal deformation processes in disordered systems (glasses, amorphous solids) that were previously too computationally expensive to model with high accuracy.
• Deterministic Nature: The method preserves the deterministic nature of AQS, ensuring reproducibility, unlike thermal MD which introduces stochasticity.
• Future Directions:
  • Dynamic Step Sizing: Implementing adaptive $K$ values to balance the risk of barrier crossing against computational overhead.
  • Finite Temperature Extensions: Exploring how these alternative trajectories (which might be rejected in AQS but accessible in thermal MD) could be used to model finite-temperature plasticity.
  • Extrapolation: Developing extrapolation methods to further reduce the number of minimization steps required in the Level II phase.

In conclusion, this paper presents a significant advancement in computational materials science by enabling the efficient, parallel tracing of energy-minimizing deformation paths in complex molecular systems without sacrificing the accuracy of the solution.