Source-linked AI summary
Assessment and optimization of the fast inertial relaxation engine (FIRE) for energy minimization in atomistic simulations and its implementation in LAMMPS
Julien Guénolé, Wolfram G. Nöhring, Aviral Vaid, Frédéric Houllé, Zhuocheng Xie, Aruna Prakash, Erik Bitzek
TL;DR
Atomistic energy minimization needs reliable methods for finding low-energy structures, but common line-search algorithms can fail or stop prematurely. This paper studies FIRE’s integration and parameters, proposes FIRE 2.0, and implements it in LAMMPS. FIRE 2.0 generally outperforms the original FIRE and conjugate gradient across the reported cases, though performance depends on integration choices and stopping criteria.
Problem
Atomistic simulations require energy minimization for equilibrium structures and stability analysis, while line-search methods can fail to reach sufficiently low residual forces.
Method
The paper evaluates FIRE’s integration schemes and parameters, modifies the algorithm, and implements FIRE 2.0 in LAMMPS.
Results
FIRE 2.0 performs better than the original FIRE in all test cases and is generally faster than FIRE or conjugate gradient, with reported speedups up to more than 3×.
Takeaways & Limitations
The correct integration scheme and minimization parameters are crucial for FIRE 2.0 performance, and the method can produce lower-energy structures than other algorithms.
Takeaways & Limitations
Cross-code comparisons require the exact force-based stopping criterion because LAMMPS’s f2norm can be several orders stricter than criteria used elsewhere.
Abstract
from arXiv · showhide
In atomistic simulations, pseudo-dynamics relaxation schemes often exhibit better performance and accuracy in finding local minima than line-search-based descent algorithms like steepest descent or conjugate gradient. Here, an improved version of the fast inertial relaxation engine (FIRE) and its implementation within the open-source code LAMMPS is presented. It is shown that the correct choice of time integration scheme and minimization parameters is crucial for performance.
1. Introduction
Energy minimization in atomistic simulations finds equilibrium structures, energies, and stability thresholds, while FIRE is studied as an improved alternative to common descent methods. The paper examines FIRE’s numerical integration and parameter choices and implements FIRE 2.0 in LAMMPS.
- Uses of energy minimization: Energy minimization of E(x) with respect to atomic coordinates yields 0 K equilibrium structures and energies.These configurations can initialize molecular-dynamics simulations or normal-mode analyses.
- Uses of energy minimization: Minimization methods are used to determine stability under load, including Peierls stress and critical stress intensity factors.They also support transition-state searches and transition detection in accelerated molecular-dynamics methods.
- Existing methods: Atomistic simulation packages commonly provide steepest descent, conjugate gradient, damped-dynamics methods, and, less widely, quasi-Newton methods.The listed damped-dynamics methods include Microconvergence, Quickmin, and FIRE.
- Existing methods: FIRE is used across simulations of metals, ceramics, polymers, carbon allotropes, amorphous materials, granular media, catalysis, and docking.Its strict force minimization suits critical-point analysis in translationally invariant systems where line-search descent can fail.
- Paper contribution: The paper studies FIRE’s integration scheme and minimization parameters, proposes a modification, and implements FIRE 2.0 in LAMMPS.Parameters include the mixing coefficient and initial and maximum timesteps.
2. The algorithms
FIRE uses pseudo-dynamics with adaptive integration and velocity–force mixing to descend the potential-energy landscape. The paper emphasizes that variable timesteps require a robust integrator and introduces overshoot correction for FIRE 2.0.
- FIRE principle: FIRE treats the potential energy as a landscape and performs dynamics designed to allow only downhill motion.The system coordinates define the landscape, while forces provide the descent direction.
- FIRE dynamics: The force is F(x(t)) = −∇E(x(t)), and the velocity-alignment term reduces the angle between velocity and the steepest-descent force.The power P(t) = F(x(t)) · v(t) detects uphill motion; velocity is reset when P(t) ≤ 0.
- FIRE updates: FIRE mixes velocity and force using an adaptive factor α(t), while positive power increases the timestep and negative power resets velocity, timestep, and α.Algorithm 1 applies these updates conditionally during each minimization iteration.
- Integration choice: Because FIRE varies the timestep, its integrator must remain robust under timestep changes; explicit Euler is unsuitable, whereas symplectic schemes are more robust.The paper considers Euler semi-implicit, Leapfrog, and Velocity Verlet integration.
- FIRE 2.0 modification: FIRE 2.0 corrects overshoot by moving backward half a timestep after discrete integration detects uphill motion.A half-step correction is less aggressive than reversing an entire timestep.
3. Implementation in LAMMPS
The LAMMPS implementation evaluates multiple integration schemes and modifies FIRE’s update logic. FIRE 2.0 also adds stopping behavior for repeated unsuccessful uphill-motion attempts.
- Integration schemes: LAMMPS’s existing FIRE implementation used a dedicated Explicit Euler integrator, unlike its regular-dynamics Velocity Verlet integrator.The paper implements Euler Explicit, Euler Semi-implicit, and Velocity Verlet methods for comparison.
- Integration schemes: Leapfrog differs from Euler semi-implicit only in velocity initialization and is nearly identical here because FIRE 2.0 repeatedly resets velocities.Leapfrog is retained in LAMMPS for testing but excluded from FIRE 2.0 assessment.
- Algorithm modifications: FIRE 2.0 delays timestep increases and α decreases after power becomes negative, then moves velocity–force mixing to just before the final integration step.The mixing change has no effect when FIRE uses Euler explicit integration.
- Stopping criteria: FIRE 2.0 stops when consecutive iterations with P(t) < 0 exceed a threshold, preventing unnecessary looping in narrow valleys.LAMMPS exposes this threshold through vdfmax and returns MAXVDOTF.
- Stopping criteria: LAMMPS’s f2norm stopping criterion is the Euclidean norm of the 3 × N force vector and can be several orders stricter than criteria used by other codes.Comparisons across codes should report the exact force-based stopping criterion.
4. Usage of fire 2.0 in lammps
LAMMPS selects FIRE 2.0 with `min_style fire2` and tunes it through `min_modify`. A usage example combines Velocity Verlet, a maximum timestep, and force-based termination settings.
- LAMMPS commands: LAMMPS performs energy minimization with `minimize`, while `min_style fire2` selects FIRE 2.0.The `min_modify` command tunes minimization parameters listed in Table 1.
- Example usage: The example uses `integrator verlet` and sets `tmax 6.0` for FIRE 2.0.The command also requests minimization until the force criterion is met or the force-evaluation limit is reached.
- LAMMPS parameters: Table 1 lists `min_modify` arguments, possible values, defaults, and descriptions for FIRE 2.0 parameters.Default values are shown in brackets.
- Example usage: The example stops when f2norm falls below 10^-6 eV/Å or after 10,000 force evaluations, with a maximum timestep of 0.012 ps.These settings operationalize force-based convergence and a computational stopping limit.
5. Assessing fire 2.0 for typical applications in material science
Across eight material-science test cases, FIRE 2.0 was evaluated against conjugate gradient and FIRE while varying integration schemes and minimization parameters. Its performance depended strongly on the integrator and parameter choices, with advantages over FIRE broadly and over conjugate gradient in most tested cases.
- FIRE versus FIRE 2.0: FIRE 2.0 outperforms FIRE in every test case, with speedups ranging from 1.8× and 2.9× for NEB cases to 10× and 30× in cases 5 and 1.The comparison uses force evaluations; cases 3, 4, and 6 do not reach the desired threshold with FIRE because convergence is too slow.
- Parameter selection: Best alpha0 values lie between 0.10 and 0.25, while large tmax values favor alpha0 around 0.10–0.15 and can sharply reduce performance.For the examined system, choosing timestep values at least four times larger than 1 fs leads to poor performance; reducing tmax can improve stability.
- Preconditioning and pre-relaxation: A 100-iteration Quickmin pre-relaxation improves case 2 by nearly 30% and also improves its Velocity-Verlet stability, but provides no gain in the other problems.Preconditioners may reduce the observed difference between conjugate gradient and FIRE 2.0, especially for large systems.
- Comparison with conjugate gradient: FIRE 2.0 generally outperforms conjugate gradient, but case 4 with free-boundary nanoporous Au is an exception and cases 2, 3, 4, and 6 expose convergence differences.Conjugate gradient fails at the strict 10−8eV/˚A threshold in nanoporous Au cases 3 and 4, cannot relax case 2, and fails to reduce forces sufficiently in case 6.
- Integration schemes: The time-integration scheme is the most important performance factor: Euler Implicit is robust, while Explicit Euler performs poorly and Velocity Verlet shows problem-dependent behavior.Velocity Verlet performs slightly better in problems 1, 3, and 5, but has stability issues in problem 2 and in NEB problem 8.
6. Summary
The paper describes FIRE 2.0, an optimized FIRE implementation in LAMMPS, and reports advantages over FIRE and conjugate gradient across materials-science examples. FIRE 2.0 can be significantly faster and produce lower-energy structures that other algorithms do not find.
- FIRE 2.0 is an optimized version of FIRE implemented within the LAMMPS molecular-dynamics simulator.
- The choice of time-integration scheme is crucial for FIRE minimization.
- Explicit Euler integration should not be used with FIRE 2.0.
- FIRE 2.0 is significantly faster than FIRE or conjugate gradient across several materials-science examples.
- FIRE 2.0 can produce lower-energy structures not found by other algorithms.
- The authors intend FIRE 2.0 to replace the existing FIRE implementation and improve the accuracy and efficiency of force minimization in atomistic systems.
Data availability
The paper states that FIRE 2.0 source code is freely available, while the raw data required to reproduce the findings cannot currently be shared.
- The FIRE 2.0 implementation source code is freely available online as described in Appendix B.
- The raw data needed to reproduce the findings cannot currently be shared because it is part of an ongoing study.
Appendix A. Integration in fire 2.0
Appendix A lists four FIRE 2.0 integration schemes and their update sequences for velocities, positions, forces, and energy.
- Explicit Euler integration: Explicit Euler mixes velocity with force, updates position, then updates velocity using the force at the new position.
- Semi-implicit Euler integration: Semi-implicit Euler updates velocity from the current force, mixes it with force, then updates position using the new velocity.
- Leapfrog integration: Leapfrog initializes half-step velocity, advances it with the current force, mixes it with force, and updates position from the half-step velocity.
- Velocity Verlet integration: Velocity Verlet performs a half-step velocity update, mixes velocity with force, updates position, recalculates force, and completes the velocity update.
Appendix B. Source code of fire 2.0
The FIRE 2.0 source code is available through LAMMPS-related online repositories and is intended to replace the current FIRE implementation.
- FIRE 2.0 is being incorporated into the master branch of LAMMPS and should replace the current FIRE implementation.
- A development version is available as a LAMMPS fork in the GitHub repository of JG, on the adaptglok branch.