VASP

The Vienna Ab initio Simulation Package (VASP) is a computer program for atomic scale materials modelling, e.g. electronic structure calculations and quantum-mechanical molecular dynamics, from first principles.

Reference: VASP website

Licensing

If you wish to use the pre-built VASP binaries on Cedar or Graham, you must write to us requesting access to VASP with the following information:

• Include license holder (your PI) information:
  1. Name
  2. Email address
  3. Department and institution (university).
• Include license information:
  1. Indicate the version of VASP license (VASP version 4 or version 5).
  2. The license number.
  3. Provide an up-to-date list of who is allowed to use your VASP license. For example, copy to us the most recent email from the VASP license administrator that contains the list of licensed users.

If you are licensed for version 5 you may also use version 4, but a version 4 license does not permit you to use version 5.

Using pre-built VASP

Run module spider vasp to see what versions are available. Choose your version using module load vasp/<version>. See Using modules for more.

Pseudopotential files

All pseudopotentials have been downloaded from the official VASP website and untarred. They are all located in $EBROOTVASP/pseudopotentials/ on Cedar and Graham and can be accessed once the VASP module is loaded.

Executable programs

For VASP-4.6, there are three different executable files:

• vasp for standard NVT calculations with non-gamma k-points
• vasp-gamma is used for standard NVT calculation and only gamma-point
• makeparam is used to estimate how much memory is required to run VASP for a particular system

For VASP-5.4.1, 5.4.4 (without cuda module), and 6.1.0 (without cuda module) there are three different executable files as well:

• vasp_std for standard NVT calculation and non-gamma k-points
• vasp_gam for standard NVT calculation and only gamma-point
• vasp_ncl for NPT ensemble and non-gamma-point calculations

For VASP-5.4.4 and 6.1.0 with cuda module there are two different executable files as well:

• vasp_gpu for standard NVT calculation gamma and non-gamma k-point
• vasp_gpu_ncl for NPT ensemble and both, gamma and non-gamma-point calculations

Two extensions have also been incorporated:

• Transition State Tools
• VASPsol

If you need a version of VASP that does not appear here, you can either build it yourself (see below) or write to us and ask that it be built and installed.

Vasp-GPU

Vasp-GPU executable files run on both GPU and CPU of a node. Basically calculation on GPU of a node is much more expensive than CPU, therefore we highly recommend to perform a benchmark using one or 2 GPU to make sure they are using maximum GPU utilization. Fig.1 show a benchmark of Si crystal contains 256 Si-atoms in the unit-cell. Blue, black and red lines show simulation time as a function of Number of CPU for GPU=0, 1, and 2 respectively. It shows the performance for GPU=1,2 and CPU=1 is more than 5 times better compare to GPU=0 and CPU=1. However, a comparison between calculation with GPU=1 and GPU=2 indicates that there is not much performance gain from GPU=1 to GPU=2. In fact GPU utilization for GPU=2 is around 50% in our monitoring system. Therefore we recommend users to first perform a benchmark like this for their own system to make sure they are not wasting any computer resources.

File:Vasp-GPU-benchmark.pdf

Building VASP yourself

If you are licensed to use VASP you may download the source code from the VASP web site and build custom versions. See Installing software in your home directory and Installing VASP.

Example of a VASP job script

The following is a job script to run VASP in parallel using the Slurm job scheduler:

File : vasp_job.sh

#!/bin/bash
#SBATCH --account=<ACCOUNT>
#SBATCH --ntasks=4             # number of MPI processes
#SBATCH --mem-per-cpu=1024M    # memory
#SBATCH --time=0-00:05         # time (DD-HH:MM)
module load vasp/<VERSION>
srun <VASP>

• The above job script requests four CPU cores and 4096MB memory (4x1024MB).
• <ACCOUNT> is a Slurm account name; see Accounts and projects if you don't know what to put there.
• <VERSION> is the VASP version that you would like to run, 4.6, 5.4.1, 5.4.4 or 6.1.0.
• <VASP> is the name of the executable. The above section "Executable programs" shows the various executables that you can choose for each version.

File : vasp_gpu_job.sh

#!/bin/bash
#SBATCH --account=<ACCOUNT>
#SBATCH --cpus-per-task=1      # number of CPU processes
#SBATCH --gres=gpu:p100:1      # Number of GPU type:p100 (valid type only for cedar)
#SBATCH --mem=3GB              # memory
#SBATCH --time=0-00:05         # time (DD-HH:MM)
module load vasp/<VERSION>
mpiexec <VASP>

• The above job script requests one CPU core and 1024MB memory.
• The above job script requests one GPU type p100 which is only available in cedar. For any other machines please see which GPU type is available
• The above job uses mpiexec to run vasp.

VASP uses four input files named as: INCAR, KPOINTS, POSCAR, POTCAR. It is best to prepare VASP input files in a separate directory for each job. To submit the job from that directory, use:

sbatch vasp_job.sh

If you do not know how much memory you need for your job, prepare all your input files and then run makeparam in an interactive job submission. Then use the result as required memory for the next run. However, for a more accurate estimate for future jobs, check the maximum stack size used by completed jobs, and use this as the memory requirement per processor for the next job.

If you want to use 32 or more cores, please read about whole-node scheduling.

Message Passing Interface