#

Installation notes for ABINIT v1.8

This file provides a description of the operations needed to install the ABINIT package, to generate the executable and to make the tests.

See a recent version of the file 'new_user_guide', for an introduction to the abinit package. See a recent version of the file 'abinis_help' for learning how to use the code. Both of them can be found in the Infos subdirectory.

Any comment of suggestion to improve the installation will be wellcome ! Simply contact the ABINIT group.

##### Copyright (C) 1998-2001 ABINIT group (XG,DCA)
This file is distributed under the terms of the GNU General Public License, see ~abinit/COPYING or http://www.gnu.org/copyleft/gpl.txt .
For the initials of contributors, see ~abinit/doc/developers/contributors .

## Summary :

- How to get a version of ABINIT ?
- How to make the executable ?
- How to make the internal tests ?
- How to make the other tests ?
- Things that are NOT in the installation files.

## How to get a version of ABINIT ?

We will distinguish two cases :

1. you have a F90 compiler and you want to compile the source files.
2. you run a platform that exists also in Louvain-la-Neuve, and you do not want to compile the source files.

In both cases, the installation files are available on the web site.

You can also get them by a direct access to the machines in Louvain-la-Neuve, if you have an UserID.
In case 1), you should have an access to hilbert.pcpm.ucl.ac.be (or equivalently, bohr.pcpm.ucl.ac.be, since the disks are NFS-shared).
In case 2), you must access the corresponding platform in Louvain-la-Neuve (however, the installation files for the Linux/Intel platform can also be found on hilbert.pcpm.ucl.ac.be).

From now on, we suppose that you have either access to the web site, or to the machine and the proper official directory.

You must get the following files (x.x.x is the version):

Case 1 (you want to compile) : src_tests_x.x.x.tar.Z

> This compressed tar file contains all the sources of the ABINIT code (including the files needed for generating the FFTs, NumRecip and Lapack libraries), the complete Infos directory, the complete set of Tests, all the scripts and makefiles, the pseudopotentials needed for tests.
> It does NOT contain the object files and the binary executable files.

Case 2 (you do not want to compile) : platform_x.x.x.tar.Z

> This compressed tar file contains the binary executable files, the complete Infos directory, and the different files needed to execute the 5 internal tests only.
> It does NOT contain the source files, or the Test_fast, Test_v1 and Test_cpu directories, and the corresponding pseudopotentials. The possible platforms are : intel_linux, ibm_pw2, dec_osf, hp_pa7200, hp_pa8000, sgi_r10000 . For the Intel/Linux machines, the binaries contain all the libraries routines statically linked. They should be very portable (and they have been ported to more that 5 different machines in different countries, or of different constructors). However, they have been compiled by a compiler that generates code that needs an IP number to work. So, they will not run if your machine has not been IP'ed. For the other platform, the executable do not contain all the library routines (they are linked dynamically), so they might not be as portable.

So, execute the following actions :

> 1) Transfer the above-mentioned file(s) to your machine, in a directory referred to here as ~local_ABINITvx.x.x . You should have about 30 MB of disk space to install the code, maybe more, depending on the version.

> 2) Uncompress and untar the file 'src_tests_x.x.x.tar.Z' or 'platform_x.x.x.tar.Z' :

> > uncompress -c src_tests_x.x.x.tar.Z | tar -xvf -

> > or

> > uncompress -c platform_x.x.x.tar.Z | tar -xvf -

If correctly done, a whole set of subdirectories should have been created. One of them is called 'Infos'. It contains many important informations. In particular, you will find the description of the different subdirectories in the file ~local_ABINITvx.x.x/Infos/content_of_dirs . This file also describes the content of the Infos directory, that is, all the information files.

*** It is strongly adviced to the installer to read (and print) NOW this file. ***

## How to make the executable ?

If you were in case 2, then you already have the binary executables abinis and newsp, so that you can skip the present section and go to the internal testing. However, just for fun, you can issue the make command :

> make

This will print the list of available keywords for the make utility.

We now suppose that you have a F90 compiler and you want to compile the source files (case 1).

You will have to issue again the 'make' command, however with some keyword appended.

To get the sequential version of the two executables abinis and newsp, you must type :

> make allseq or make allseq >& log.file

(allseq is an abbreviation for all sequential executables; log.file can be any filename, and is useful when the messages from make are too long)

Issuing this 'make allseq' command will trigger a whole set of actions (not easy to follow, as you will see).
The make utility will use the file 'Makefile', that calls a script called 'makemake', to produce another makefile, called 'tmp_makefile', that calls different 'makemake' scripts in different subdirectories, that create themselves 'tmp_makefile' files, that compile the fortran source (and eventually one C file), create libraries and link the different objects.
Moreover, usually, this works without problem !

However, you must first provide to the 'make' utility some information: the location of F90 and C compilers on your machine, the cpp utility, the blas library ... For this, you must create in the ~local_ABINITvx.x.x directory a symbolic link named 'makefile_macros' to a machine-dependent file, that you will have to design starting from already existing files. The 'makemake' scripts use that 'makefile_macros' file to do their job.

Examples of such files are contained in the subdirectories of the ~local_ABINITvx.x.x/Machine_dept_files directory. An help file called help.makefile_macros can be found in the ~local_ABINITvx.x.x/Infos directory.

Let's us suppose that you do not issue the powerful 'make allseq' command, but that you want to create one-by-one the libraries and executables.

Then, for the sequential version, you must create :

- the lapack library (make lapack)
- the numrecip library (make numrecip)
- the ffts library (make ffts)

Alternatively, the three libraries can be created at once by issuing 'make libs'.

Then, you can issue 'make abinis' to make the sequential version of abinis, and 'make newsp' to make newsp, the wavefunction translator. The way to generate the parallel version of the abinit code, called abinip, is not described here.

Suppose that something is going wrong in one of the above-mentioned steps, then, you can issue one of the 'clean_xxx' keywords (those mentioned by typing 'make') to clean the directory where something wrong happened.

With a bit of chance, you will succeed to generate the executables abinis and newsp. You are ready to perform the tests.

## How to make the internal tests ?

The abinis code has five internal tests, that can be issued automatically, and that check themselves whether the results that have been obtained are right or wrong.

You can begin with the test number 1. Simply issue the command :

> make test1

It will run during a dozen of seconds. It will first print

> cd Test_in; rm -f *1*o* *1*S ; ../abinis < test1.files > test1.log 2>&1 &
> Test_in/test_end Test_in/test1 ; cat Test_in/test1_STATUS

then, you will eventually (if you are on a slow machine) see different instances of the status file, like the following :

> Status file, with repetition rate 20 , status number 101

> Level abinit : call gstate
> Level gstate : call brdmin
> Level brdmin : call scfcv_ini
> Level scfcv : call vtorho
> istep = 2
> Level vtorho : compute rhog

then, the important information is as follows :

> Status file, reporting on test 1

> OK for total energy
> OK for nuclei positions
> OK for forces
> OK for stresses

This means that the internal test 1 ran successfully. If you do not get this message, then the executable were not properly generated, or there is a problem with the make and scripts that drive the internal test. In this case, after having tried to solve the problem by yourself, you should contact somebody in the ABINIT group. Note : the script detects the end of the run by using the 'ps' command following by a 'grep' command.

This can lead to strange effects if a file whose name contain 'abinis' is currently visualized, or if another job is running under a name that contains 'abinis'.
So, close your files before running the tests, and also check that there are no running jobs whose name contains 'abinis'.

Supposing test1 was OK, then you have to issue the command 'make tests'.

The test 1 will be done once more, followed by the 4 other internal tests. Again, we hope that you will get the positive diagnostics for the other tests. Altogether, these tests are about 1 minute on a PPro 200 MHz machine where no other job is running.

For further information on these internal tests, see the file ~local_ABINITvx.x.x/Infos/build_in_tests .

## How to make the other tests (case 1 only)?

(Case 1 only, since in case 2, only the minimal testing tools have been transferred)

You should now look at the subdirectories Test_fast, Test_v1 and Test_cpu .

Please, read the corresponding 'README' file carefully (at least the beginning), then read the beginning of the scripts 'Run'.

In order to execute these tests, you need a larger disk space than for the simple installation of the code (the total additional space required is on the order of 40 MB). After having checked the results of the tests, the user can easily retain the output files in a compressed form, and get rid off the wavefunction files by issuing

> make decrease_size_tests

in the ~local_ABINITvx.x.x directory.

1) Test_fast

This subdirectory contains a basic set of tests of the code, aimed at testing whether the code is coherent in time (successive versions), and exercising many parts of the code. However, they does not examine its accuracy on physical problems, mainly because the number of plane waves used is too small, and some tests are not lead to self-consistent convergence.
This suite of tests is similar to the suite of tests used for the plane_wave code. There should be reasonable similarity between the results of the tests for the plane_wave and ABINIT codes.
To run the tests, simply issue :

> (Run machine_name) >& log

where machine_name will usually be the name of your machine (any other character string is fine, however).
The script will create a directory whose name will be build from the machine name and today's date. All the results will be in that directory. The output files will be automatically compared, thanks to a 'diff' command, to a set of reference files, either from the plane_wave code (the corresponding difference files are prefixed by 'diff.'), or from a recent run of the ABINIT code (the corresponding difference files are prefixed by 'difnew.').

2) Test_v1

This directory contains tests build in the same spirit than those in the Test_fast directory, but that exercise features not present in the plane_wave code, like the treatment of metals, the GGA, or the new pseudopotentials.
These were developped during the time the version 1 of ABINIT was set up.
Of course, the automatic difference procedure only compares to recent runs of the ABINIT code.

3) Test_cpu

This subdirectory contains the scripts, and input files needed for testing the cpu time, either on progressively finer real space grids, or on progressively bigger unit cells. Please read the README file of this directory. Also for this suite of tests, you have simply to issue

> (Run machine_name) >& log

Unlike in the previous case, many directories will be created (8 in the present version). Their name begins with the test name (A1, Am2, A3, B1, Bm2, B3, C3, D3), and is followed by the machine name and the date. Inside these directories, many runs are done.
There is a 'report' file that summarizes the timing of the different runs, and there is a 'diff' file, that compares these timings with the reference (output from a PPro at 200 MHz).

## Things that are NOT in the installation files.

- Pseudopotentials :
  The installation files contains a few pseudopotentials, for testing purposes. But many other pseudopotential have been generated. There exist presently two complete sets of ready-to-use LDA pseudopotentials, for the whole periodic table : those generated by Doug for the plane_wave code, and those published by Hartwigsen, Goedecker, Hutter (I am not sure whether this is published already). Doug's pseudopotentials are on the Web site, but can also be obtained from him, or can be found in the directory ~gonze/ABINITv1/Psps/TM.psps of the hilbert machine in Louvain-la-Neuve. In the directory ~gonze/ABINITv1/Psps, you will find two pseudopotential codes whose output can be read by the ABINIT code, eventually after some minor modification. The ABINIT code is also able to read pseudopotentials generated by the Hartwigsen-Goedecker-Hutter code. The web site does not contain all the pseudopotentials that the code is able to use.
- Symmetries and k-point utility :
  There exist also a utility for generating automatically symmetries and k-point for a given unit cell and atomic configuration, that is not contained in the installation files. This utility, called kptgen, is also available from Doug or from the ~gonze/kpoints.Doug (I have to check this reference) subdirectory of the Hilbert machine. It should be included in the ABINIT package sooner or later, and is not documented here.

page : Home | Calcul Intensif | Calcul ab initio

6 Jéanvier 1999. Responsable : Xavier Gonze < gonze@pcpm.ucl.ac.be> Conception : Jean-Michel Beuken < beuken@pcpm.ucl.ac.be> |