I know that parallelization is an important factor, however, I wanted to know if there are any other methods of reducing computing time when dealing with large systems without sacrificing accuracy.



There isn't a single correct answer to this question, and it depends on what is slow, what kind of material you are modeling, and what you are trying to calculate. This answer is mostly going to be partially copied from my blog post here.

Geometry Optimizations

  • Don’t waste your time using super high-accuracy settings on a structure far from the local minimum. Do an initial optimization with “looser” settings (e.g. gamma-point only for the k-point grid, 400 eV cutoff if relaxing the atomic positions) and then incrementally refine it with the desired (but more computationally expensive) parameters. The one exception to this general comment is that, when performing geometry optimizations that involve changes in the cell shape and/or volume, always ensure that ENCUT > 1.3*ENMAX to prevent Pulay stresses. You don't want to cheapen out on this. But on the whole, you often don't need to use your "production-quality" settings for the full duration of a given structure relaxation.

  • When performing a full optimization of atomic positions and cell shape/volume, I generally recommend to do this in stages. It is often wise to start with a relaxation of the atomic positions (ISIF=2) followed by a full volume relaxation (ISIF=3). This will also significantly reduce the chance of running into convergence issues.

  • Whenever you can, restart from a converged wavefunction (i.e. the WAVECAR). The WAVECARs are not transferable between the gamma-point only and standard versions of VASP, but otherwise you should try to restart from them when possible to make the SCF converge quicker on a restart.

  • The first step in a geometry optimization will generally have the highest number of SCF iterations. It is okay if those first few steps do not converge electronically within the limits of NELM (maximum number of SCF iterations). In fact, it is better to have the first step reach NELM instead of running for many hundreds of SCF iterations.

Electronic Energy Convergence

  • For insulating materials (or when using meta-GGA functionals), SCF convergence is greatly accelerated by using ALGO=All. This has the added benefit that you don’t have to worry about any of the mixing tags. A word of caution though -- some compilations of VASP do not play well with the ALGO=All flag for some reason and stall after a few SCF iterations, so just give it a go and see.

  • If dealing with large systems, use LREAL=Auto to speed up the calculations. You may want to switch this back to LREAL=False at the end though to ensure your energies are high-quality.

Choice of Geometry Optimization Algorithms

  • In terms of efficiency and robustness in an optimization algorithm for finding local minima, I generally recommend starting with the conjugate gradient (CG) algorithm (IBRION=2) because it is very robust and you do not have to worry about tweaking POTIM. However, in large, flexible materials with many degrees of freedom, the CG optimization algorithm oftentimes results in a bracketing error once it gets relatively close to the local minimum (search for ZBRENT: fatal error in bracketing in the standard output file). This occurs because the potential energy surface is very flat, and the CG algorithm implemented in VASP is based on the energy differences. One option to fix this is to use FIRE as implemented with VTST (IBRION=3, IOPT=7). It should get you to that local minimum quicker, particularly when the potential energy surface is quite flat.

  • Generally, for nudged elastic band (NEB) calculations and the climbing image variant (CI-NEB), I have found that the the L-BFGS algorithm (IOPT=1) implemented in VTST is often the fastest. For the dimer method, the force-based CG method in VTST (IOPT=2) is recommended. However, if you are having trouble in either case, I suggest switching to the FIRE algorithm (IOPT=7) with the default settings. It is a bit slower, but it is especially useful in troublesome cases of convergence.

Parallel Performance

  • Whenever feasible, take advantage of the gamma-point only VASP executable, as it runs up to 1.5 times faster than the standard executable.

  • Try tweaking the NCORE or NPAR flags to adjust the scaling performance. The optimal value for NCORE strongly varies based on the computing environment. I generally use NCORE=cpus-per-node or NCORE=cpus-per-node/2 as a first guess.

  • 1
    $\begingroup$ Great insight, I will take it into consideration. Thank you!! $\endgroup$ – Daniel Maldonado May 2 '20 at 15:55
  • 2
    $\begingroup$ Very good answer with great tips $\endgroup$ – Thomas May 2 '20 at 22:54

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.