Skip to content

VASP

What is VASP?

The Vienna Ab initio Simulation Package (VASP) is a software package for performing electronic structure calculations with periodic boundary conditions. It is most commonly used to perform density functional theory (DFT) calculations in a plane wave basis using the projector augmented wave (PAW) method.

For a full documentation of VASP, visit: https://www.vasp.at

Using VASP at ALCF

VASP is commercial software. Access to binaries compiled by ALCF can only be granted after the user requesting access has been verified to be on the VASP license by an official VASP license distributor.

To access the VASP binary at ALCF, please email the details listed directly below to [email protected]. It can take up to 5–10 business days to verify a VASP license.

Information to provide:

  • User’s full name:
  • User’s ALCF username:
  • Name of the organization that purchased the VASP license:
  • VASP license purchased from (University of Vienna or MaterialsDesign):
  • Principal investigator who is the POC for the VASP license:
  • VASP license number:
  • Version of VASP requested (VASP 6.x):

Support policy

ALCF suport team compiles the latest release of VASP on a per-request basis. We do not offer support for compiling customized versions of VASP or with plugins. Support for scientific runs that encounter performance or numerical issues should be directed to the official VASP support mailing list or the VASP user forum. ALCF can provide limited help with fatal runtime errors encountered on ALCF systems.

Once the user licence is validated, ALCF will add the user to the UNIX groups: vasp65 or vasp6 , and grant access to the subdirectories in /soft/applications/vasp.

How to obtain the code

The VASP source can only be obtained from an official license reseller of VASP. This is either the University of Vienna or Material Designs, Inc.

Building VASP 6.6.x on Aurora

This section describes a VASP 6.6.x build configuration for Aurora using:

  • oneAPI
  • OpenMP offload
  • Cray MPI

General compiling/installing instructions provided by VASP support

Instructions and samples of makefile.include can be found on the vasp.at wiki page.

The example below was adapted for Aurora from the VASP wiki page for makefile.include found here.

makefile.include
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
# Precompiler options
CPP_OPTIONS = -DHOST=\"LinuxIFC\" \
              -DMPI -DMPI_BLOCK=8000 -Duse_collective \
              -DscaLAPACK \
              -DCACHE_SIZE=4000 \
              -Davoidalloc \
              -Dvasp6 \
              -Dtbdyn \
              -Dfock_dblbuf \
              -D_OPENMP \
              -DINTELMKL

CPP         = fpp -f_com=no -free -w0  $*$(FUFFIX) $*$(SUFFIX) $(CPP_OPTIONS)

FC          = mpif90 -fc=ifx -fiopenmp
FCL         = mpif90 -fc=ifx
FREE        = -free -names lowercase

FFLAGS      = -assume byterecl -w

OFLAG       = -O2
OFLAG_IN    = $(OFLAG)
DEBUG       = -O0

# For what used to be vasp.5.lib
CPP_LIB     = $(CPP)
FC_LIB      = $(FC)
CC_LIB      = icx
CFLAGS_LIB  = -O
FFLAGS_LIB  = -O1
FREE_LIB    = $(FREE)

OBJECTS_LIB = linpack_double.o

# For the parser library
CXX_PARS    = icpx
LLIBS       = -lstdc++

LIB        += oneapi
LLIB       += -Loneapi -lZeInterface

# OMP offloading
CPP_OPTIONS+= -DOMP_OFFLOAD
# this enables offloading plus AoT compiling of target device code
FFLAGS     += -fopenmp-targets=spir64_gen -Xs "-device pvc"


# Workarounds for problems with fpp and ifx
FFLAGS     += -switch no-use-host-usm-for-implicit-reduction-map
IFX_BUILD_DATE = $(shell ifx --version | grep ifx | awk '{print $$4}')
CPP_OPTIONS+= -D__INTEL_COMPILER_BUILD_DATE=$(IFX_BUILD_DATE)

##
## Customize as of this point! Of course you may change the preceding
## part of this file as well if you like, but it should rarely be
## necessary ...
##

# When compiling on the target machine itself, change this to the
# relevant target when cross-compiling for another architecture
VASP_TARGET_CPU ?= -xHOST
FFLAGS     += $(VASP_TARGET_CPU)

# Intel MKL (FFTW, BLAS, LAPACK, and scaLAPACK)
FCL        += -qmkl -fiopenmp -fopenmp-targets=spir64_gen -Xs "-device pvc" -fopenmp-device-code-split=per_kernel -fopenmp-max-parallel-link-jobs=8 -lze_loader
MKLROOT    ?= /path/to/your/mkl/installation
LLIBS      += -L$(MKLROOT)/lib/intel64 -lmkl_scalapack_lp64 -lmkl_blacs_intelmpi_lp64 -lmkl_sycl
INCS        =-I$(MKLROOT)/include -I$(MKLROOT)/include/fftw

# HDF5-support (optional but strongly recommended, and mandatory for some features)
#CPP_OPTIONS+= -DVASP_HDF5
#HDF5_ROOT  ?= /path/to/your/hdf5/installation
#LLIBS      += -L$(HDF5_ROOT)/lib -lhdf5_fortran
#INCS       += -I$(HDF5_ROOT)/include

# For the VASP-2-Wannier90 interface (optional)
#CPP_OPTIONS    += -DVASP2WANNIER90
#WANNIER90_ROOT ?= /path/to/your/wannier90/installation
#LLIBS          += -L$(WANNIER90_ROOT)/lib -lwannier

# For the fftlib library (hardly any benefit in combination with MKL's FFTs)
#FCL         = mpiifort fftlib.o -qmkl
#CXX_FFTLIB  = icpc -qopenmp -std=c++11 -DFFTLIB_USE_MKL -DFFTLIB_THREADSAFE
#INCS_FFTLIB = -I./include -I$(MKLROOT)/include/fftw
#LIBS       += fftlib

# For machine learning library VASPml (experimental)
#CPP_OPTIONS += -Dlibvaspml
#CXX_ML       = mpiicpc -cxx=icpx -qopenmp
#CXXFLAGS_ML  = -O3 -std=c++17 -Wall
#INCLUDE_ML   =
## This may be required for the C++17 filesystem library if the underlying
## system compiler is older than GNU 9.1. For newer versions this can be removed.
#LLIBS       += -lstdc++fs

Setting up compiler and libraries with module

The following modules will update the include and library paths used by the Cray compiler wrapper mpif90 to load additional math libraries for the CPU and GPU.

1
2
3
4
5
6
7
8
module restore
module load oneapi/release/2026.1.0
# Recommended (2026-10-08): use the newer aurora_test MPICH for working
# GPU-aware MPI. The default mpich/prd/5.0.0.aurora_test.87e2045 has a
# severely degraded GPU IPC path (see Known issues below). This needs no
# rebuild: all aurora_test builds share the libmpi.so.12 ABI, and the
# module's LD_LIBRARY_PATH takes precedence over the binary RUNPATH.
module swap mpich mpich/prd/5.0.0.aurora_test.51a9474

See Aurora system updates for the MPICH versions shipped in the September 2026 rollout.

Compiling VASP

After loading the modules and placing makefile.include in the vasp source folder, compiling all the object files and binaries is done with:

1
make -j1

Running VASP on Aurora

An example of a submission script can be found here /soft/applications/vasp/example.script.sh.

A typical submission script looks like this:

script.sh
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/bin/bash -l
#PBS -N AFFINITY
#PBS -l select=4
#PBS -l place=scatter
#PBS -l walltime=0:10:00
#PBS -l filesystems=<fs1:fs2>
#PBS -q debug-scaling
#PBS -A <project>

export TZ='/usr/share/zoneinfo/US/Central'
cd ${PBS_O_WORKDIR}

NNODES=`wc -l < $PBS_NODEFILE`
NRANKS=12 # Number of MPI ranks to spawn per node
NTHREADS=4 # Number of software threads per rank to launch (i.e. OMP_NUM_THREADS)

NTOTRANKS=$(( NNODES * NRANKS ))

echo "NUM_OF_NODES= ${NNODES} TOTAL_NUM_RANKS= ${NTOTRANKS} RANKS_PER_NODE= ${NRANKS} THREADS_PER_RANK= ${NTHREADS}"

export OMP_NUM_THREADS=${NTHREADS}
export OMP_PLACES=cores
export OMP_PROC_BIND=close
export OMP_STACKSIZE=1G


export CPU_BIND_SCHEME="--cpu-bind=list:1-8:9-16:17-24:25-32:33-40:41-48:53-60:61-68:69-76:77-84:85-92:93-100"
export GPU_BIND_SCHEME=$(which gpu_tile_compact.sh)

bin=/soft/applications/vasp/vasp.6.6.1/bin/vasp_std

mpiexec -n ${NTOTRANKS} -ppn ${NRANKS} ${CPU_BIND_SCHEME} --env OMP_NUM_THREADS=${NTHREADS} --env OMP_PLACES=cores --env OMP_STACKSIZE=1G ${GPU_BIND_SCHEME} $bin

Submission scripts should have executable attributes to be used with qsub script mode:

1
2
chmod +x script.sh
qsub script.sh

Known issues

Slow GPU-aware MPI with the default MPICH (October 2026)

Since the September 2026 rollout, GPU runs with the default mpich/prd/5.0.0.aurora_test.87e2045 are approximately 20-25x slower per SCF iteration (EDDAV, MPI collectives dominating). Workaround (2026-10-08): module swap mpich mpich/prd/5.0.0.aurora_test.51a9474 (upstream ZE IPC fix, no rebuild needed). See Aurora system updates.

VASP 6.6.1 internal compiler error with oneAPI 2026

Compiling VASP 6.6.1 with Intel oneAPI 2026 fails with the following internal compiler error:

david_full.F(2014): error #5623: **Internal compiler error: internal abort** Please report this error along with the circumstances in which it occurred in a Software Problem Report. Note: File and line given may not be explicit cause of this error.
!$OMP TEAMS WORKDISTRIBUTE IF(OFFLOAD_ON)
--------^

To work around it, edit line 2015 of src/david_full.F (the statement following the !$OMP TEAMS WORKDISTRIBUTE directive) and remove the explicit array section on the right-hand side. Change

src/david_full.F
2015
                    CPROJ(1:NPRO,N) = GCIJP(1:NPRO)

to

src/david_full.F
2015
                    CPROJ(1:NPRO,N) = GCIJP