ABINIT is a quantum chemistry software based on the DFT (Density Functional Theory) method.

It was developed by Xavier Gonze and Jean-Michel Beuken of the “Unité de Physico-Chimie et de Physique des Matériaux” of the Catholic University of Leuven, Belgium.

Documentation is available on the ABINIT Website.


The available versions are:

  • 7.0.5 MPI
  • 7.4.1 MPI (default version)
  • 7.4.1 MPI/OpenMP hybrid
  • 7.6.2 MPI/OpenMP hybrid
  • 7.10.4 MPI/OpenMP hybrid

The MPI parallel and MPI/OpenMP hybrid versions (if appropriate) are installed.

Launching script

The following is an example of a hybrid parallelisation launching script for a calculation run in WORKDIR:

# @ job_name         = ABINIT
# @ output           = $(job_name).$(jobid)
# @ error            = $(job_name).$(jobid)
# @ job_type         = parallel
# @ total_tasks      = 32
# @ parallel_threads = 4
# @ wall_clock_limit = 1:00:00
# @ queue
### Module initialisation ###
module load abinit/7.6.2
### Command echoes ###
set -x
### Run the calculation ###
poe abinit < abinit.files > out.log

The following is an example of an MPI parallelisation launching script for a calculation run in TMPDIR:

# @ job_name         = ABINIT
# @ job_type         = parallel
# @ output           = $(job_name).$(jobid)
# @ error            = $(job_name).$(jobid)
# @ wall_clock_limit = 1:00:00
# @ total_tasks      = 64
# @ queue
### Module initialisation ###
module load abinit
### Command echoes ###
set -x
### Copy to the TMPDIR ###
### Input files should be placed in a subdirectory ###
cp ./input/* $TMPDIR
### Run the calculation ###
poe abinit < abinit.files > out.log
### Copy to the submission folder ###
cd -
cp $TMPDIR/* .

More complete advice about Ada job submission in queue may be found on Execution of a parallel MPI code in batch or Execution of a hybrid MPI/OpenMP parallel code in batch.

Parameters specific to the software


Two complete sets of pseudopotentials for the whole periodic table are available on the ABINIT Website.

File: abinit.files

In the above examples of launching scripts, abinit.files is necessary. It contains the list of input files, the prefixes for the output files, as well as the list of pseudopotentials for calculation. If this file is not present on the executable command line, your calculation will stay blocked (as the code waits for this file list).
The file is typically constructed as follows:
file_prefixes_wave function (etc)

Parallelisation by default

ABINIT uses MPI parallelisation in numerous parts of its code. Some of these parts could benefit from an additional OpenMP parallelisation. By default, the parallelisation is done on the k points and/or on the spin states.

For best use of the resources, it is necessary to choose a number of MPI tasks (or compute cores) which is a multiple of the number of k points.   For example, without spin and for 60 k points, 30 compute cores will provide a more rapid solution than 32 cores. Complementary information can be found at ABINIT tutorials.

Automatic parallelisation (7.10+ versions)

In order to increase performance significantly compared to the default parallelisation, ABINIT can choose automatically the optimal core distribution accross the calculation steps.

To activate this mode, you have to add in the input file: AUTOPARAL=1.
The core distribution that may already be present in your input file has also to be deleted or commented (keywords npkpt, npband, npfft, max_ncpus, mkmem, paral_kgb, etc.).

KGB parallelisation (versions up to 7.6)

For calculations in the fundamental state, it is possible to obtain an even better performance by using parallelisation on the k points (K), the wave vectors (G) and the bands (B). Unfortunately, this parallelisation method is not automatic using old versions and it is necessary to indicate the number of attributed cores in order to process the k points, the bands, and the Fast Fourier Transforms (FFT). ABINIT is capable of determining the optimal configuration for the calculation but not in an automatic way. A summary of the simplest method is presented below. Other methods are available on the dedicated page of the ABINIT tutorials. Note that this method functions best when the number of cores is greater than 64.

Note that the procedure described below is only valid for versions up to and including 7.4.1. For more recent versions, consult the ABINIT tutorials.

  • The first step is to indicate the following in your input file (for example, : paral_kgb=-maximum_number_of_compute_cores_requested.
    For example, for a maximum of 512 cores :

  • Launch this calculation on only 1 core (submission script instruction: # @ total_tasks = 1). This calculation is very rapid and consists only of determining the calculation configuration.
  • For the job examples on this page, the result is found at the end of the out.log file. The best configuration corresponds to the first line in which the value of weight is the closest to 1.
    Here is an example:

     mpi_setup : COMMENT -
     For dataset=   1  a possible choice for less than  512 processors is:
      nproc     npkpt  npspinor    npband     npfft    bandpp    weight
       480       60        1         4         2         1        0.50
       240       60        1         2         2         2        0.25
       240       60        1         4         1         1        1.00
       120       60        1         2         1         2        1.00
  • You just need to retrieve the optimal parameters for your calculation. In this example, in choosing 240 compute cores (your submission script: # @ total_tasks = 240), you need to indicate paral_kgb=1 in your file (in any case, to activate the parallelisation) as well as:


This method remains the simplest and most rapid. By consulting the ABINIT site dedicated page, you will find the complete description of the precise determination of the optimal configuration, parameter by parameter. However, the method thus described could be longer and consume more resources to obtain a result which is often nearly the same result as that of the simple method.