The source code for Version 1.25 of static is designed to be compiled into a serial version for use on single processor PCs, workstations, and vector computers, or into a scalable parallel version for use on multiprocessor systems. Both versions use identical input files and produce essentially identical output. Users choose between the serial and scalable versions at build time by choosing the appropriate Makefile (see below).

static is written in Fortran-77, using MPI calls for scalable parallel performance, and a fake MPI library when running the serial version. In serial mode the code has been tested on a variety of CPUs, using various operating systems and compilers. It should be possible to run this code on any computer with a valid Fortran-77 compiler, provided the makefile is edited to reflect the appropriate compile and link options.

When compiled as a scalable parallel code, static uses the Message Passing Interface (MPI) standard for passing information between processors. It should, therefore, be quite portable between systems. The program runs on the following platforms:

Scalar Platforms

• Linux boxes using the
  • Absoft® Fortran Compiler
  • Intel® Fortran compiler
  • Portland Group Fortran compiler
  • g77 GNU Fortran compiler
• IBM platforms using AIX and the xlf Fortran compiler.
• SGI Origin platforms using the supplied Fortran compiler, and, optionally, the sgimath libraries.
• Compaq SC platforms using the DEC Alpha Fortran compiler.

Parallel Platforms (with MPI):

• IBM platforms using AIX and the mpxlf Fortran compiler.
• SGI Origin platforms using the supplied Fortran compiler, and, optionally, the sgimath libraries.
• Compaq SC platforms using the DEC Alpha Fortran compiler.

The static code should compile easily on other architectures using the native Fortran-77 compiler. The code makes calls to BLAS (Basic Linear Algebra Subprograms) and LAPACK (Linear Algebra PACKage). If these are not available on the target machine, you may try using the ATLAS (Automatically Tuned Linear Algebra Software) libraries. Alternatively, we provide Fortran versions of the necessary BLAS and LAPACK routines with our distribution.

The program will be tested on other computer architectures. Porting should involve only the changes in the makefile to reflect the system's MPI, Fortran, and linker installation. In the meantime, users are encouraged to attempt to port this code to other systems using MPI and Fortran-77. Please report both problems and successes to mehl@dave.nrl.navy.mil (Privacy Advisory). We would also appreciate a copy of the makefile used with this system, provided you are willing for it to be distributed.

The source code for static is password protected. See Obtaining the Source Code for more information.

Installing and compiling the code

The static code can be downloaded routine by routine, but it is best to get the gzipped tarball, ALLSOURCE.tgz. Once you have this package, break out the individual files using the command

gzip -cd ALLSOURCE.tgz | tar xvf

Copy all the files including the files P1, P2, P3, and the appropriate makefile into a working directory.

There are three parameter files, P1, P2 and P3, which should be edited to reflect the type of calculation you wish to perform.

• P1:
  • mkind is the maximum number of types of atoms in the parameter file. This number can safely be set to 2 even when the calculation is for a system with only one type of atoms.
  • matom is the maximum number of atoms in the calculation. While this number can be chosen to be very large, performance suffers if the number is much larger than the actual number of atoms in the problem. We are considering dynamic memory allocation to alleviate this problem.
  • mbas, the maximum basis set size per atom. Calculations involving s, p, and d orbitals require 9 orbitals per atom. Calculations involving elements such as carbon, where only the s and p orbitals are relevant, require only 4 orbitals per atom. Using 4 in this case results in a substantial savings in memory when a large number of atoms is desired, since the memory requirements go as (matom*mbas)2.
  • mppair is a guess at the average number of atoms "seen" by each atom in the calculation. Typically, for metals mppair should be chosen to be 300-500. If this number is too small the program will not function correctly. The total number of pair interactions in the problem can be found by looking for the string Number of pairs = in the SKOUT output file. mppair must be greater than this number divided by matom.
  • mspin must be set to 2 if you are using a spin-polarized parameter set, as in our ferromagnetic and antiferromagnetic examples. Otherwise, you can set mspin = 1. Using mspin = 2 for non-polarized parameters is allowed, but costs memory and may cause increased computational time.
• P2

  The parameters mpress and meigen must be set to 1 under certain conditions. Under other circumstances they may be set to zero, which will reduce the memory requirements.

  • If you need the system eigenvectors for any reason, including partial density of states, or for the calculation of the pressure, set meigen = 1.
  • To calculate Hellmann-Feynman forces, including the pressure (the only such "force" currently implemented), set mpress = 1. Since this requires the eigenvectors of the problem, the parameter meigen must also be set to 1.
• P3:
  • nkd is maximum number of k-points to be used in the calculation. Various k-point meshes have been generated, or you can use the program to generate k-points as outlined in the usage section. Again, if this number is too large performance may suffer.
  • nopd is maximum number of space group operations to be used in the calculation. We usually set it to 48, the maximum number of operations available in a crystal. There is little to be gained by reducing this value to reflect the highest symmetry of your calculation.
  • minproc is the lower bound on the number of processors in the current run. Trying to run a job with fewer processors will generate an error message and abort the run. This means that minproc must be set to 1 for scalar computing. Using the highest value possible for minproc will save system memory.
• The remaining parameters in these files should be left as is, unless you have a good reason to change them.

Now that the parameter files have been properly edited, the program may be compiled using make. Several architecture-dependent Makefiles are bundled into the distribution, e.g.

	 $ ls -l makefile.*
	 -rw-r--r-- 1 user group 4679 Aug 23 13:16 makefile.absoft
	 -rw-r--r-- 1 user group 4053 Aug 22 17:14 makefile.aix.parallel
	 -rw-r--r-- 1 user group 3847 Aug 22 17:14 makefile.aix.single
	 -rw-r--r-- 1 user group 5831 Aug 22 17:14 makefile.alpha
	 -rw-r--r-- 1 user group 4209 Aug 22 17:14 makefile.g77
	 -rw-r--r-- 1 user group 4270 Aug 23 15:15 makefile.intel
	 -rw-r--r-- 1 user group 4263 Aug 23 13:57 makefile.pg
	 -rw-r--r-- 1 user group 3992 Aug 22 17:14 makefile.sgi

If one of the makefiles matches your system, say for the SP2, you can directly compile the program:

$ make -f makefile.aix.parallel

works on an IBM. Note that many routines have multiple options, in which case you can specify one of them on the command line. For example, to use the ATLAS libraries with the Absoft Linux compiler, edit the NLIB statement in the makefile to point to the proper libraries, and then give the command

$ make -f makefile.absoft newblas

If your system does not appear on the list above, edit the makefile which most closely matches your system, and run make on that file.

When changing compilers or compiler options, it is best to do a clean command, e.g.

$ make -f makefile.absoft clean

before starting compilation. This removes all the old object files and forces recompilation of every routine. Note that you do not have to do a clean if you are only changing values of the P[1,2,3] files, as the makefile will determine which routines need to be recompiled.

More information and options for this program are contained in the INSTALLATION file contained in the distribution.

IMPORTANT: On a single processor machine static uses the mpifake.f file to mimic several MPI subroutines, and mpifake.h to mimic the mpif.h header file. In order for this to work your makefile must copy mpifake.h to mpif.h before any routines are compiled. See makefile.absoft for one way to accomplish this. Note that, as far as the code is concerned, mpif.h could be an empty file.

static Home Page   Introduction   About Version 1.25   Installation   List of Files   Usage   Input Files   Output Files   Trouble Shooting   Appendix

Current URL: http://cst-www.nrl.navy.mil/bind/static/installation.html