Assuming all has gone well with the configuration (you'll generally get an error message if configuration fails), you're ready to compile

and install APBS:

For those with obsessive-compulsive tendencies, you can also test the APBS binary you just compiled against a suite of benchmark jobs by running

You should be able to watch the various tests pass on your platform. If they don't pass, please let us know by posting to the APBS-USERS mailing list. These tests can also be run before make install is executed.  You can test the Opal version of APBS (TO-DO:  NAB ADD LINK) separately by typing

This follows a similar set of tests as the normal make test described above. However, because of runtime dependencies, the make test-opal command must be run after APBS has been installed (i.e. after make install has been issued).

Please note: If you have tips or tricks on improving APBS performance and/or installation on your machine, let us know!

This section provides tips on compiling APBS on specific platforms and outlines some of the basic options available for parallel execution, Python linkage, etc. Note that many aspects of this section have changed from previous releases. In particular, APBS now tries to detect the optimal compilers and BLAS libraries on most systems without user intervention.

As described above, the default configure-make-install procedure is

The configure script includes a number of generic options to manually set default compilers, link behaviors, preprocessors, etc. These can be reviewed by running

If an optimized (vendor) BLAS library is available, it should be used with APBS since it will generally provide better performance. This can be enabled by the --with-blas=... option. The configure-make-install procedure for a custom BLAS library is:

where /path/to/blas is the the path to a directory which contains a library named libblas.a.

Core APBS functionality can also be invoked via Python for inclusion in other applications and more complicated scripting environments. Python library support is enabled at configure-time. Currently, Python libraries compile on most Linux and Mac systems. Other systems are untested. The configure-make-install procedure for enabling Python extensions is:

Starting with APBS 1.2, we now support two different types of parallel execution. Parallel focusing is still supported through the distributed memory (MPI) support that has been available since very early versions of APBS. Information on enabling distributed memory support is available below. Additionally, we have begun to add shared memory support (OpenMP) into a subset of the algorithms in APBS; this support will expand in future versions of APBS. Shared memory support is enabled by default if a supported system configuration is detected. Information on supported systems and procedures for disabling OpenMP support is provided below.

Starting with APBS 1.2, we now support shared memory parallel acceleration for a subset of the algorithms in APBS, including:

• Acceleration of boundary condition evaluation
• Acceleration of the Gauss-Seidel smoothing algorithm in the multigrid cycle

This support is enabled by default if one the following compilers are identified during configuration:

• Intel icc/ifort versions greater than or equal to 10
• GNU gcc/gfortran versions greater than or equal to 4.2

On average, the numerical results change by less than 0.001%. Differences are caused by a change in the Gauss-Seidel smoother in the multigrid cycle: the serial implementation has been changed to parallel red-black.

OpenMP support can be disabled by adding the --disable-openmp flag during configuration; e.g.

At runtime, users can specify the number of threads to use. By default all processors/cores will be used at runtime; however, this behavior can be changed via environmental variables. For example, under bash, you can type

in your shell prior to running APBS. In this usage, X = the number of threads. Note: It is NOT a good idea to use a number for X greater than the number of available cores on your system. However, if hyperthreading is enabled, you can try running with twice the number of cores.

Since very early releases, APBS uses MPI for parallel focusing calculations. In general, enabling MPI support requires informing the APBS configure script about:

MPI compiler options. For most MPI implementations, you simply need to set the CC and F77 variables to point to the MPI-savvy C and FORTRAN compilers. However, it is occasionally necessary to manually specify compiler options by setting CFLAGS, CPPFLAGS, FFLAGS, and LDFLAGS environmental variables before configuration.

MPI library/header file locations. As outlined below, paths to the library and header files for LAM, MPICH, or Open MPI implementations of MPI can be specified with the --with-lam, --with-mpich, or --with-mpich2 configure options. Other MPI implementations will require the CFLAGS, CPPFLAGS, FFLAGS, and LDFLAGS environmental variables to be set correctly before configuration to locate the required headers and libraries.

It is important that you enable FORTRAN support and use the same compilers you will use to compile APBS when installing/compiling LAM MPI. For example, if your C compiler is set in the environmental variable CC and your FORTRAN compiler is set in the environmental variable F77, then you should configure LAM with the command

Let MPI_PREFIX be an environmental variable pointing to the directory where LAM MPI is installed. In other words, ${MPI_PREFIX}/lib should contain the LAM MPI libraries and ${MPI_PREFIX}/include should contain the LAM MPI header files. The configure-make-install procedure is then

This procedure was tested with LAM MPI 7.2.1.

It is important that you enable FORTRAN support and use the same compilers you will use to compile APBS when installing/compiling MPICH1. For example, if your C compiler is set in the environmental variable CC and your FORTRAN compiler is set in the environmental variable F77, then you should configure MPICH1 with the command

where ... denotes other machine-specific options required by the MPICH compiler (e.g., --with-device=ch_p4 or --with-arch=LINUX).  MPI_PREFIX should be an environmental variable pointing to the directory where MPICH1 is installed. In other words, ${MPI_PREFIX}/lib should contain the MPICH1 libraries and ${MPI_PREFIX}/include should contain the MPICH1 header files. The configure-make-install procedure is then

This procedure was tested with MPICH1 1.0.6p1.

It is important that you enable FORTRAN support and use the same compilers you will use to compile APBS when installing/compiling MPICH2.

Let MPI_PREFIX be an environmental variable pointing to the directory where MPICH2 is installed. In other words, ${MPI_PREFIX}/lib should contain the MPICH2 libraries and ${MPI_PREFIX}/include should contain the MPICH2 header files. The configure-make-install procedure is then

This procedure was tested with MPICH2 1.2.7p1.

It is important that you enable FORTRAN support and use the same compilers you will use to compile APBS when installing/compiling OpenMPI.

Let MPI_PREFIX be an environmental variable pointing to the directory where OpenMPI is installed. In other words, ${MPI_PREFIX}/lib should contain the OpenMPI libraries and ${MPI_PREFIX}/include should contain the OpenMPI header files. The configure-make-install procedure is then

This procedure was tested with OpenMPI 1.2.8.

In order to enable support for the finite element features in APBS, you must compile it against the FEtk libraries. Please use the same compilers for both APBS and FEtk. Let FETK_PREFIX be an environmental variable pointing to the directory where FEtk was installed. In other words, ${FETK_PREFIX}/lib should contain the FEtk machine-specific library directories and ${FETK_PREFIX}/include should contain the FEtk header files. Note that FEtk installs library files in directories designated with the GNU "machine triplet". Therefore, you'll first need to identify the appropriate library directory for your system in ${FETK_PREFIX}/lib. For the purposes of this example, let's suppose this directory is ${FETK_PREFIX}/lib/x86_64-unknown-linux-gnu. The configure-make-install procedure for APBS is then

We provide native APBS command line binaries for Windows; these binaries are probably the best options for most Windows users.  However, if you would still like to compile your own binaries you will need to use either the Cygwin or MinGW environments. Binaries compiled under Cygwin tend to require Cygwin DLLs and thus can only be run on systems with Cygwin. Performance for the Windows binaries and all compiled systems will be fairly mediocre as they depend on the GNU compilers.  If you do choose to use Cygwin and compile your own code, compilation should be rather straightforward. Good luck.

We provide Mac install packages for Mac OS X versions greater than 10.4. Users on Mac OS 10.3 or older will have to compile binaries for themselves - and may want to examine the apbs-users mailing list which has a number of threads which discuss installation on Mac OS platforms.

A few notes about compiling on Macintosh:

• It has become apparent from the mailing lists that some "packages" of the GNU development software available for MacOS contain different major versions of the C and FORTRAN compilers. This is very bad; APBS will not compile with different versions of the C and FORTRAN compilers. If you use GCC 4.0, for instance, gfortran 4.0 will work while g77 3.3 will not. If you see link errors involving "restFP" or "saveFP" this is most likely the cause.
• In gcc 4.0 (included in Xcode 2.0 and higher) the -fast option turns on the -fast-math flag. This flag optimizes by using rounding, and thus can lead to inaccurate results and should be avoided.
• Currently the autoconf script does not support using the native vecLib framework as an architecture-tuned BLAS replacement. In testing there were only slight timing improvements over using the MALOC-supplied BLAS.
• For older PowerPC-based systems: we have had success using IBM's XLF for Mac in conjunction with GCC 4.0, although the corresponding XLC compilers do not seem to work under Tiger.
• Finally, Dave Gohara has prepared a nice tutorial on building APBS from within Xcode to take advantage of its development and debugging features.