configure

#!/bin/bash
# CPPTRAJ standalone configure script.
# Daniel R. Roe
# 2010-11-18
# Rewritten 2018-01-25 (getting old...)
# Support for getting and building external libraries (get_library.sh) added 2021-03-03
# This script will determine compiler and linker flags based on
# desired user-specified options. Generates config.h, which is
# used by src/Makefile.

#-------------------------------------------------------------------------------
# Print simple help message
UsageSimple() {
  echo "Usage: ./configure <OPTIONS> [gnu | intel | pgi | clang | cray | oneapi]"
  echo "  OPTIONS:"
  echo "    --help         : Display this message."
  echo "    --prefix <dir> : Install CPPTRAJ to specified directory (default is this directory)."
  echo "    -openmp        : Use OpenMP for parallelization of certain routines."
  echo "    -mpi           : Use mpicc/mpicxx to compile."
  echo "    -intelmpi      : Use mpiicc/mpiicpc to compile."
  echo "    -cuda          : Enable CUDA support. See SHADER_MODEL in --full-help for more info."
  echo "    -hip           : Enable HIP support."
  echo "    -cray          : Use cray compiler wrappers (cc/CC/ftn)."
  echo "    -amberlib      : Use BLAS/ARPACK/LAPACK/NetCDF libraries from \$AMBERHOME"
  echo "    -cmake         : Use cmake; 'configure' must be executed in a separate directory."
  echo "    --full-help    : Display additional options."
  echo ""
}

#-------------------------------------------------------------------------------
# Print more detailed options
UsageFull() {
  UsageSimple
  echo "  ADDITIONAL OPTIONS"
  echo "    -debug     : Turn on compiler debugging info."
  echo "    -noopt     : Do not use optimized compiler flags."
  echo "    -tune      : Enable host-specific compiler optimizations."
  echo "    -noc++11   : Disable C++11 support."
  echo "    -d         : Turn on compiler debug info and disable optimization (i.e. -debug -noopt)."
  echo "    -timer     : Enable additional timing info."
  echo "    -debugon   : Add -DDEBUG flag to activate additional internal debugging."
  echo "    -nolfs     : Do not enable large file support."
  echo "    -shared    : Configure for generating libcpptraj (implies -nosanderlib)."
  echo "    -pubfft    : Use pubfft instead of FFTW for FFT (disables PME functionality)."
  echo "    -windows   : Set up for use with MinGW compilers for a native Windows build."
  echo "  LIBRARY OPTIONS"
  echo "    -<lib>             : Enable library."
  echo "    --with-<lib>=<DIR> : Use library in specified directory."
  echo "    -l<lib>=<FILE>     : Use specified library file."
  echo "    -no<lib>           : Disable library."
  echo "    --buildlibs        : Attempt to build enabled libraries if they are not present."
  echo "    --nobuildlibs      : Do not asking about building enabled libraries."
  echo "    -makenetcdf        : Have cpptraj build its own NetCDF."
  echo "    -makeblas          : Have cpptraj build its own LAPACK/BLAS."
  echo "    --libdir=<dir>     : Look for libraries in <dir> (useful to point to e.g. a previous CPPTRAJ install."
  echo "    Libraries: netcdf pnetcdf zlib bzlib blas lapack arpack fftw3 readline sanderlib xdrfile tng openmm"
  echo "    Note: pnetcdf is needed for writing NetCDF trajectories with MPI."
  echo "  LINKING OPTIONS"
  echo "    -static        : Use static linking."
  echo "    -libstatic     : Use static linking only for specified libraries."
  echo "    -mkl           : Use Intel MKL for BLAS/LAPACK (requires MKL_HOME/MKLROOT set)."
  echo "    -nomklfftw     : Prevent use of FFTW from MKL."
  echo "    -openblas      : Use OpenBLAS for BLAS/LAPACK (may require '--with-blas' or '-lblas')."
  echo "                     May also want to specify '-larpack' if included in OpenBLAS."
  echo "    -macAccelerate : Use Accelerate framework for BLAS/LAPACK."
  echo "    -libsci        : Use Cray LibSci for BLAS/LAPACK."
  echo "  ENVIRONMENT VARIABLES (can also be passed to configure as <VAR>=<VALUE>):"
  echo "    CXX          : Name of the C++ compiler."
  echo "    CC           : Name of the C compiler."
  echo "    FC           : Name of the Fortran compiler."
  echo "    MPICXX       : Name of MPI C++ compiler."
  echo "    MPICC        : Name of MPI C compiler."
  echo "    MPIF90       : Name of MPI Fortran compiler."
  echo "    CXXFLAGS     : Flags to pass to the C++ compiler."
  echo "    CFLAGS       : Flags to pass to the C compiler."
  echo "    FFLAGS       : Flags to pass to the Fortran compiler."
  echo "    LDFLAGS      : Flags to pass to the linker."
  echo "    TUNEFLAGS    : Host-specific tuning flags. Will override '-tune'."
  echo "    NVCC         : Name of the nvcc/hipcc compiler."
  echo "    NVCCFLAGS    : Flags to pass to the nvcc/hipcc compiler."
  echo "    DBGFLAGS     : Any additional flags to pass to all compilers."
  echo "    CUDA_HOME    : (-cuda) Path to CUDA installation."
  echo "    HIP_HOME     : (-hip) Path to ROCm installation (default is '/opt/rocm')."
  echo "    SHADER_MODEL : (-cuda) Should be set to 'sm_XX', where XX is CUDA compute architecture."
  echo "                   sm_86 = GA102, 104, 106, 107"
  echo "                   sm_80 = GA100"
  echo "                   sm_75 = Turing"
  echo "                   sm_72 = GV10B"
  echo "                   sm_70 = GV100"
  echo "                   sm_62 = GP10B"
  echo "                   sm_61 = GP106 = GTX-1070, GP104 = GTX-1080, GP102 = Titan-X[P]"
  echo "                   sm_60 = GP100 / P100 = DGX-1"
  echo "                   sm_53 = GM200 [Grid] = M60, M40?"
  echo "                   sm_52 = GM200 = GTX-Titan-X, M6000 etc."
  echo "                   sm_50 = GM204 = GTX980, 970 etc"
  echo "                   sm_37 = GK210 = K80"
  echo "                   sm_35 = GK110 = K20[x], K40, GTX780, GTX-Titan, GTX-Titan-Black, GTX-Titan-Z"
  echo "                   sm_30 = GK104 = K10, GTX680, 690 etc."
  echo "                   sm_20 = All GF variants = C2050, 2075, M2090, GTX480, GTX580 etc."
  echo "  EXPERIMENTAL OPTIONS:"
  echo "    --compile-verbose : Turn on compile details."
  echo "    -profile          : Use Gnu compiler profiling (>= V4.5)*"
  echo "    -gprofile         : Use Gnu compiler GLIBC profiling (>= V4.5)*"
  echo "    -vtune            : Enable options for use with Intel Vtune."
  echo "    -single-ensemble  : Enable support for reading/writing single ensemble trajectories."
  echo "    -leappi           : Use LEaP's value of PI for converting radians/degrees."
  echo ""
  echo "*NOTE: -profile and -gprofile are mutually exclusive."
  echo ""
}

# ----- Script variables -------------------------------------------------------
WORKDIR=`dirname $0`      # Working directory of the configure script
CURRENTDIR=`pwd`          # Directory configure is being executed in
COMPILERS=''              # User-specified compiler suite to use.
FLINK=''                  # Flag for linking in Fortran code
REQUIRES_FLINK=0          # If 1 FLINK flag required during link phase
REQUIRES_PTHREAD=0        # If 1 -lpthread required during link phase
C11FLAG=''                # Flag for compiling C++11 code
C11_SUPPORT='yes'         # Support C++11 code
SHARED_SUFFIX=''          # Suffix for shared libraries
DBFLAG=''                 # Flag for turning on compiler debug symbols
DIRECTIVES=''             # Common compiler directives
CPPTRAJ_INC=''            # Library header include line
SFX=''                    # Binary suffix
EXE=''                    # Binary executable suffix
REBUILDOPT=''             # Can be set to --rebuild and passed to get_library.sh
BUILDTESTOPT='silent'     # Set to blank to avoid asking about building libraries
INSTALL_DAT='install_dat' # Target for installing data directory
SPECIFIED_LIB_DIR=''      # Specified library directory
LIBDIR='lib'              # Set by SetLibDir() to lib or lib64
#CPPTRAJSRC=''             # CPPTRAJ source directory
COMPERR='cpptrajcfg.compile.err'
COMPOUT='cpptrajcfg.compile.out'

# ----- Variables for downloading libraries ------
NETCDF_SRCTAR='v4.9.2.tar.gz'
NETCDF_SRCDIR='netcdf-c-4.9.2'
NETCDF_URL="https://github.com/Unidata/netcdf-c/archive/refs/tags/$NETCDF_SRCTAR"
NETCDF_OPTS=" --disable-byterange --disable-libxml2 --disable-netcdf-4 --disable-dap --disable-nczarr $windows_hostflag --disable-shared --disable-doxygen"
NETCDF4_OPTS=" --disable-byterange --disable-libxml2 --disable-dap --disable-nczarr $windows_hostflag --disable-shared --disable-doxygen"

HDF5_SRCTAR='hdf5-1_10_9.tar.gz'
HDF5_SRCDIR='hdf5-hdf5-1_10_9'
HDF5_URL="https://github.com/HDFGroup/hdf5/archive/refs/tags/$HDF5_SRCTAR"
HDF5_OPTS=''

BZIP2_SRCTAR='bzip2-latest.tar.gz'
BZIP2_SRCDIR=''
BZIP2_URL="https://www.sourceware.org/pub/bzip2/$BZIP2_SRCTAR"
BZIP2_OPTS=''

ZLIB_SRCTAR='zlib-1.3.1.tar.gz'
ZLIB_SRCDIR='zlib-1.3.1'
ZLIB_URL="https://zlib.net/$ZLIB_SRCTAR"
ZLIB_OPTS=''

OPENBLAS_SRCTAR='OpenBLAS-0.3.13.tar.gz'
OPENBLAS_SRCDIR='OpenBLAS-0.3.13'
OPENBLAS_URL="https://github.com/xianyi/OpenBLAS/releases/download/v0.3.13/$OPENBLAS_SRCTAR"
OPENBLAS_OPTS=''

LAPACK_SRCTAR='v3.9.0.tar.gz'
LAPACK_SRCDIR='lapack-3.9.0'
LAPACK_URL="https://github.com/Reference-LAPACK/lapack/archive/$LAPACK_SRCTAR"
LAPACK_OPTS=''

PNETCDF_SRCTAR='pnetcdf-1.12.2.tar.gz'
PNETCDF_SRCDIR=''
PNETCDF_URL="https://parallel-netcdf.github.io/Release/$PNETCDF_SRCTAR"
PNETCDF_OPTS='--disable-fortran --disable-cxx'

FFTW_SRCTAR='fftw-3.3.9.tar.gz'
FFTW_SRCDIR='fftw-3.3.9'
FFTW_URL="https://fftw.org/pub/fftw/$FFTW_SRCTAR"
FFTW_OPTS='--enable-threads --with-combined-threads --with-pic --disable-fortran'

# ----- Variables for downloading MPI ------------
MPI_MPICH_SRCTAR='mpich-3.4.2.tar.gz'
MPI_MPICH_SRCDIR='mpich-3.4.2'
MPI_MPICH_URL="http://www.mpich.org/static/downloads/3.4.2/$MPI_MPICH_SRCTAR"
MPI_MPICH_OPTS='--with-device=ch3'

# ----- Configure options ------------------------
USE_CMAKE=0       # 1 = use cmake for build
COMPILE_VERBOSE=0 # 1 = show details during compile
USE_MPI=0         # 0 = no MPI, 1 = mpicc etc, 2 = mpiicc etc
USE_OPENMP=0      # 0 = no OpenMP, 1 = OpenMP
USE_CUDA=0        # 0 = no CUDA, 1 = CUDA
USE_HIP=0         # 0 = no HIP, 1 = HIP
USE_OPT=1         # 0 = no optimization, 1 = use compiler optimizations, 2 = optimize/tune.
BLAS_TYPE='other' # none|mkl|libsci(cray)|openblas|macAccelerate|other=normal BLAS
MKL_TYPE='mkl'    # mkl = -mkl for Intel compilers, line = link-line advisor style
MKL_FFTW=''       # If yes, use FFTW from MKL if not otherwise specified. If 'no' prevent this.
USE_DEBUG=0       # 0 = no debug info, 1 = enable compiler debug info
USE_STATIC=0      # 0 = dynamic linking, 1 = static linking, 2 = static link for specified libraries
USE_SHARED=0      # 1 = Use flag for position-independent code (required for libcpptraj)
USE_PROFILE=0     # 0 = no profiling, 1 = C++ profiling, 2 = GLIBC profiling, 3 = Intel Vtune
USE_AMBERLIB=0    # 1 = Use AMBERHOME to fill in NetCDF/BLAS/LAPACK/ARPACK as needed
BUILD_LIBS=0      # 1 = Means automatically say yes to building enabled libs when not present.
BUILD_MPI=''      # If not empty, attempt to download and build specified mpi dist.
icpp=0            # Used to count cmake_prefix_paths

USE_SINGLEENSEMBLE=0 # Enable support for single ensemble trajectories
USE_CPPTRAJDEBUG=0   # Enable internal cpptraj debug flags
USE_LEAP_PI=0        # Use LEaP's value of PI for converting radians/degrees

CLEAN='yes'          # yes = clean after configure, no = do not
PERFORM_CHECKS='yes' # yes = Check compilers/libraries, no = do not

# Flags for large file support
LFS='-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64'

# Install locations
CPPTRAJHOME=''
CPPTRAJBIN=''
CPPTRAJLIB=''
CPPTRAJINC=''
CPPTRAJDAT=''

# ----- External Libraries -----------------------
# Library indices
# Original: FFT ARPACK LAPACK BLAS NETCDF PARANC BZIP ZIP READLINE XDRFILE
# Libraries containing definition of a function should appear *after*
# any source files or object files which use it.
LNETCDF=0
LPARANC=1    # Parallel NetCDF
LBZIP=2
LTNGFILE=3   # This has to come before ZLIB since it depends on ZLIB
LZIP=4
LARPACK=5
LLAPACK=6
LBLAS=7
LFFTW3=8
LREADLINE=9
LXDRFILE=10
LTIMER=11
LCUDA=12
LHIP=13
LOPENMM=14
LHDF5=15
LSANDER=16  # Make sure this comes last to avoid pulling in unnecessary symbols
# Total number of external libraries
NLIB=17

# LIB_STAT = Library status:
#   off       : Do not use library.
#   enabled   : Try to use library.
#   specified : Library directory has been specified.
#   amberopt  : Use library from AMBERHOME - optional.
#   optional  : Enabled if found, disabled if not.
#   bundled   : Use bundled version of library.
#   direct    : Library location directly specified.
LIB_STAT[$LNETCDF]='enabled'         # off, enabled, specified, amberopt, optional, bundled, direct
LIB_CKEY[$LNETCDF]='netcdf'          # Command-line key for '-', '--with-' and '-no'
LIB_HOME[$LNETCDF]=''                # Library home directory (-L<home>)
LIB_FLAG[$LNETCDF]='-lnetcdf'        # Library linker flag
LIB_STTC[$LNETCDF]='libnetcdf.a'     # Expected static location relative to home
LIB_D_ON[$LNETCDF]='-DBINTRAJ'       # Directive if library on
LIB_DOFF[$LNETCDF]=''                # Directive if library off
LIB_LINK[$LNETCDF]='dynamic'         # How to link the library
LIB_TYPE[$LNETCDF]='ld'              # ld = LDFLAGS, cpp = cpptraj/libcpptraj, cpptraj=cpptraj only, blank = special

LIB_STAT[$LPARANC]='off'
LIB_CKEY[$LPARANC]='pnetcdf'
LIB_HOME[$LPARANC]=''
LIB_FLAG[$LPARANC]='-lpnetcdf'
LIB_STTC[$LPARANC]='libpnetcdf.a'
LIB_D_ON[$LPARANC]='-DHAS_PNETCDF'
LIB_DOFF[$LPARANC]=''
LIB_TYPE[$LPARANC]='ld'

LIB_STAT[$LBZIP]='enabled'
LIB_CKEY[$LBZIP]='bzlib'
LIB_HOME[$LBZIP]=''
LIB_FLAG[$LBZIP]='-lbz2'
LIB_STTC[$LBZIP]='libbz2.a'
LIB_D_ON[$LBZIP]='-DHASBZ2'
LIB_DOFF[$LBZIP]=''
LIB_TYPE[$LBZIP]='ld'

LIB_STAT[$LZIP]='enabled'
LIB_CKEY[$LZIP]='zlib'
LIB_HOME[$LZIP]=''
LIB_FLAG[$LZIP]='-lz'
LIB_STTC[$LZIP]='libz.a'
LIB_D_ON[$LZIP]='-DHASGZ'
LIB_DOFF[$LZIP]=''
LIB_TYPE[$LZIP]='ld'

LIB_STAT[$LBLAS]='enabled'
LIB_CKEY[$LBLAS]='blas'
LIB_HOME[$LBLAS]=''
LIB_FLAG[$LBLAS]='-lblas'
LIB_STTC[$LBLAS]='libblas.a'
LIB_D_ON[$LBLAS]=''
LIB_DOFF[$LBLAS]='-DNO_MATHLIB'
LIB_TYPE[$LBLAS]='cpp'

LIB_STAT[$LLAPACK]='enabled'
LIB_CKEY[$LLAPACK]='lapack'
LIB_HOME[$LLAPACK]=''
LIB_FLAG[$LLAPACK]='-llapack'
LIB_STTC[$LLAPACK]='liblapack.a'
LIB_D_ON[$LLAPACK]=''
LIB_DOFF[$LLAPACK]=''
LIB_TYPE[$LLAPACK]='cpp'

LIB_STAT[$LARPACK]='bundled'
LIB_CKEY[$LARPACK]='arpack'
LIB_HOME[$LARPACK]='arpack'
LIB_FLAG[$LARPACK]='-larpack'
LIB_STTC[$LARPACK]='libarpack.a'
LIB_D_ON[$LARPACK]=''
LIB_DOFF[$LARPACK]='-DNO_ARPACK'
LIB_TYPE[$LARPACK]='cpp'

LIB_STAT[$LFFTW3]='enabled'
LIB_CKEY[$LFFTW3]='fftw3'
LIB_HOME[$LFFTW3]=''
LIB_FLAG[$LFFTW3]='-lfftw3'
LIB_STTC[$LFFTW3]='libfftw3.a'
LIB_D_ON[$LFFTW3]='-DFFTW_FFT'
LIB_DOFF[$LFFTW3]=''
LIB_TYPE[$LFFTW3]='cpp'

LIB_STAT[$LREADLINE]='enabled'
LIB_CKEY[$LREADLINE]='readline'
LIB_HOME[$LREADLINE]=''
LIB_FLAG[$LREADLINE]='-lreadline'
LIB_STTC[$LREADLINE]='libreadline.a'
LIB_D_ON[$LREADLINE]=''
LIB_DOFF[$LREADLINE]='-DNO_READLINE'
LIB_TYPE[$LREADLINE]=''

LIB_STAT[$LXDRFILE]='bundled'
LIB_CKEY[$LXDRFILE]='xdrfile'
LIB_HOME[$LXDRFILE]='xdrfile'
LIB_FLAG[$LXDRFILE]='-lxdrfile'
LIB_STTC[$LXDRFILE]='libxdrfile.a'
LIB_D_ON[$LXDRFILE]=''
LIB_DOFF[$LXDRFILE]='-DNO_XDRFILE'
LIB_TYPE[$LXDRFILE]='cpp'

LIB_STAT[$LSANDER]='amberopt'
LIB_CKEY[$LSANDER]='sanderlib'
LIB_HOME[$LSANDER]=''
LIB_FLAG[$LSANDER]='-lsander'
LIB_STTC[$LSANDER]=''
LIB_D_ON[$LSANDER]='-DUSE_SANDERLIB'
LIB_DOFF[$LSANDER]=''
LIB_TYPE[$LSANDER]='cpptraj'

LIB_STAT[$LTIMER]='off'
LIB_CKEY[$LTIMER]='timer'
LIB_FLAG[$LTIMER]='-lrt'
LIB_D_ON[$LTIMER]='-DTIMER'
LIB_TYPE[$LTIMER]='ld'

LIB_STAT[$LCUDA]='off'
LIB_CKEY[$LCUDA]='cuda'
LIB_HOME[$LCUDA]=''
LIB_FLAG[$LCUDA]='-lcudart'
LIB_STTC[$LCUDA]=''
LIB_D_ON[$LCUDA]='-DCUDA'
LIB_DOFF[$LCUDA]=''
LIB_TYPE[$LCUDA]='cpp'

LIB_STAT[$LHIP]='off'
LIB_CKEY[$LHIP]='hip'
LIB_HOME[$LHIP]=''
LIB_FLAG[$LHIP]='-lamdhip64'
LIB_STTC[$LHIP]=''
# TODO: Replace __HIP_PLATFORM_HCC__ after 4.1 rocm release
LIB_D_ON[$LHIP]='-DCUDA -D__HIP_PLATFORM_HCC__'
LIB_DOFF[$LHIP]=''
LIB_TYPE[$LHIP]='cpp'

LIB_STAT[$LTNGFILE]='bundled'
LIB_CKEY[$LTNGFILE]='tng'
LIB_HOME[$LTNGFILE]='tng'
LIB_FLAG[$LTNGFILE]='-ltng_io'
LIB_STTC[$LTNGFILE]='libtng_io.a'
LIB_D_ON[$LTNGFILE]='-DHAS_TNGFILE'
LIB_DOFF[$LTNGFILE]=''
LIB_TYPE[$LTNGFILE]='cpp'

LIB_STAT[$LHDF5]='enabled'
LIB_CKEY[$LHDF5]='hdf5'
LIB_HOME[$LHDF5]=''
LIB_FLAG[$LHDF5]=''
LIB_STTC[$LHDF5]='libhdf5.a'
LIB_D_ON[$LHDF5]='-DHAS_HDF5'
LIB_DOFF[$LHDF5]=''
LIB_LINK[$LHDF5]='dynamic'
LIB_TYPE[$LHDF5]='ld'

LIB_STAT[$LOPENMM]='off'
LIB_CKEY[$LOPENMM]='openmm'
LIB_HOME[$LOPENMM]=''
LIB_FLAG[$LOPENMM]='-lOpenMM'
LIB_STTC[$LOPENMM]=''
LIB_D_ON[$LOPENMM]='-DHAS_OPENMM'
LIB_DOFF[$LOPENMM]=''
LIB_TYPE[$LOPENMM]='cpp'

for ((i=0; i < $NLIB; i++)) ; do
  LIB_LINK[$i]='dynamic'
  LIB_DISABLED[$i]='false'
done

#-------------------------------------------------------------------------------
# Print error message to stderr
ErrMsg() {
  >&2 echo "Error: $*"
}

#-------------------------------------------------------------------------------
# Print error message to stderr and exit.
Err() {
  ErrMsg $*
  exit 1
}

#-------------------------------------------------------------------------------
# Print warning message to stderr
WrnMsg() {
  >&2 echo "Warning: $*"
}

#-------------------------------------------------------------------------------
# SetLibDir <prefix> <lib>
# Search for <prefix>/lib64/<lib> and set LIBDIR to lib64 if found.
SetLibDir() {
  LIBDIR='lib'
  checklibfile="$1/lib64/$2"
  if [ -f "$checklibfile" ] ; then
    LIBDIR='lib64'
  fi
}

#-------------------------------------------------------------------------------
# Check for '--with' and '-no' library keys.
CheckLibraryKeys() {
  for ((i=0; i < $NLIB; i++)) ; do
    LKEY="-"${LIB_CKEY[$i]}
    if [ "$1" = "$LKEY" ] ; then
      # If previously bundled, clear home
      if [ "${LIB_STAT[$i]}" = 'bundled' ] ; then
        LIB_HOME[$i]=''
      fi
      LIB_STAT[$i]='enabled'
      echo "  ${LIB_CKEY[$i]} enabled."
      return 0
    fi
    LKEY="--with-"${LIB_CKEY[$i]}
    if [ "$1" = "$LKEY" ] ; then
      LIB_HOME[$i]=$2
      LIB_STAT[$i]='specified'
      echo "  ${LIB_CKEY[$i]} specified: $2"
      return 0
    fi
    LKEY="-no"${LIB_CKEY[$i]}
    if [ "$1" = "$LKEY" ] ; then
      LIB_STAT[$i]='off'
      LIB_DISABLED[$i]='true'
      echo "  ${LIB_CKEY[$i]} disabled."
      return 0
    fi
    LKEY="-l"${LIB_CKEY[$i]}
    if [ "$1" = "$LKEY" ] ; then
      LIB_STAT[$i]='direct'
      LIB_FLAG[$i]=$2
      echo "  ${LIB_CKEY[$i]} location directly specified: $2"
      return 0
    fi
    LKEY="-make"${LIB_CKEY[$i]}
    if [ "$1" = "$LKEY" ] ; then
      # For now this only works for certain libraries.
      if [ "$1" != '-makeblas' -a "$1" != '-makenetcdf' ] ; then
        return 1
      fi
      echo "  Will attempt to download and build ${LIB_CKEY[$i]}"
      LIB_STAT[$i]='enabled'
      LIB_MAKE[$i]='yes'
      return 0
    fi
  done
  return 1
}
#-------------------------------------------------------------------------------
# Download and build an MPI implementation
# ARGS: <implementation>
BuildMPI() {
  echo "Attempting to download and build MPI $1 (may be time-consuming)..."
  case "$1" in
    'mpich' )
      mpi_libname='mpich'
      mpi_srcdir=$MPI_MPICH_SRCDIR
      mpi_srctar=$MPI_MPICH_SRCTAR
      mpi_url=$MPI_MPICH_URL
      mpi_opts=$MPI_MPICH_OPTS
      if [ "$COMPILERS" = 'gnu' ] ; then
        fc_version=`$FC --version | awk '{print $4; exit 0;}' | cut -d'.' -f1`
        echo "DEBUG: major version $fc_version"
        if [ "$fc_version" -ge 10 ] ; then
          mpi_fflags='-fallow-argument-mismatch'
        fi
      fi
      ;;
    * )
      Err "Unrecognized MPI: $1"
      ;;
  esac

  # Build specified MPI 
  PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS FC=$FC FFLAGS="$FFLAGS $mpi_fflags" LIBNAME=$mpi_libname \
              SRCDIR=$mpi_srcdir SRCTAR=$mpi_srctar URL=$mpi_url ./get_library.sh --rebuild $mpi_opts
  if [ $? -ne 0 ] ; then
    Err "No MPI $1 available. To build without MPI do not specify the '-mpi' flag."
  fi
}

#-------------------------------------------------------------------------------
# Test compile and run a program.
# ARGS: [noexe|silent|quiet] <description> <compiler> <args> <file> [<link>]
TestProgram() {
  if [ $BUILD_LIBS -eq 0 ] ; then
    REBUILDOPT=''
  else
    REBUILDOPT='--rebuild'
  fi
  if [ "$1" = 'noexe' ] ; then
    # Output messages, do not execute compiled binary; exit on error
    silent=3
    shift
  elif [ "$1" = 'quiet' ] ; then
    # Output nothing.
    silent=2
    shift
  elif [ "$1" = 'silent' ] ; then
    # Output messages but return 1 instead of exit 1
    silent=1
    shift
  else
    # Output message; exit on error
    silent=0
  fi
  desc="$1"
  comp="$2"
  args="$3"
  file="$4"
  link="$5 $LDFLAGS"
  if [ $silent -ne 2 ] ; then echo -n "$desc: " ; fi
  COMPILELINE="$comp $args -o testp $file $link"
  #echo "COMPILE: $COMPILELINE" #DEBUG
  $COMPILELINE > $COMPOUT 2> $COMPERR
  if [ $? -ne 0 -o ! -f 'testp' ] ; then
    if [ $silent -eq 0 -o $silent -eq 3 ] ; then
      echo ""
      ErrMsg "Test compile failed: $COMPILELINE"
      ErrMsg "Check the output below for error messages:"
      cat $COMPERR >&2
      exit 1
    else
      COMPILE_ERROR_LINE=$COMPILELINE
      COMPILE_ERROR_MESSAGE=`cat $COMPERR`
      #echo "DEBUG: Error: $COMPILE_ERROR_LINE"
      #echo "DEBUG: Error: $COMPILE_ERROR_MESSAGE"
      rm $COMPERR $COMPOUT
      return 1
    fi
  fi
  if [ $silent -ne 3 ] ; then
    ./testp > prog.out
    if [ $? -ne 0 ] ; then
      echo ""
      if [ $silent -eq 1 ] ; then
        #echo "DEBUG silent fail: $COMPILELINE"
        return 1
      fi
      Err "Run of test program failed, compiled with: $COMPILELINE"
    fi
    rm prog.out
  fi
  if [ $silent -ne 2 ] ; then echo "OK" ; fi
  rm -f $file testp $COMPERR
  return 0
}

# Error message for TestProgram silent
TestProgErr() {
  desc=$1
  echo "Failed."
  ErrMsg "$1 build/link failed: $COMPILE_ERROR_LINE"
  ErrMsg "Error message follows:"
  ErrMsg "$COMPILE_ERROR_MESSAGE"
  exit 1
}

# This is invoked if linking a bundled library fails.
CheckRebuild() {
  desc=$1
  libfile=$2
  if [ -z "$REBUILDOPT" -a -f "$libfile" ] ; then
    echo "Bundled $desc present but needs to be rebuilt."
    REBUILDOPT='--rebuild'
  fi
}

# ===== LIBRARY TESTS ==========================================================
TestBzlib() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include "bzlib.h"
int main() { BZFILE *bfile; bfile=NULL; printf("Testing\n"); return 0; }
EOF
  TestProgram silent "  Checking BZLIB" "$CXX" "$CXXFLAGS ${LIB_INCL[$LBZIP]}" testp.cpp "${LIB_FLAG[$LBZIP]}"
  if [ $? -ne 0 ] ; then
    if [ "${LIB_STAT[$LBZIP]}" = 'enabled' ] ; then
      # See if there is already a version of BZIP2 in CPPTRAJHOME
      LIB_STAT[$LBZIP]='specified'
      LIB_HOME[$LBZIP]=$CPPTRAJHOME
      LIB_FLAG[$LBZIP]=$CPPTRAJHOME/lib/${LIB_STTC[$LBZIP]}
      LIB_INCL[$LBZIP]="-I$CPPTRAJHOME/include"
      TestProgram $BUILDTESTOPT "  Checking for bundled Bzip2" "$CXX" "$CXXFLAGS ${LIB_INCL[$LBZIP]}" testp.cpp "${LIB_FLAG[$LBZIP]}"
      if [ $? -ne 0 ] ; then
        CheckRebuild "Bzip2" "${LIB_FLAG[$LBZIP]}"
        # See if user would like to get Bzip2
        PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='bzip2' \
            SRCDIR=$BZIP2_SRCDIR SRCTAR=$BZIP2_SRCTAR URL=$BZIP2_URL ./get_library.sh $REBUILDOPT $BZIP2_OPTS
        if [ $? -ne 0 ] ; then
          ErrMsg "No Bzip2 available. To build without Bzip2 specify '-nobzlib'."
          exit 1
        fi
        # Test the built Bzip2
        TestProgram "  Checking built Bzip2" "$CXX" "$CXXFLAGS ${LIB_INCL[$LBZIP]}" testp.cpp "${LIB_FLAG[$LBZIP]}"
      fi
    else
      # Bzip2 specified but failed.
      TestProgErr "Bzip2"
    fi
  fi
}

TestZlib() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include "zlib.h"
int main() { gzFile gfile; gfile=NULL; printf("Testing\n"); return 0; }
EOF
  TestProgram silent "  Checking ZLIB" "$CXX" "$CXXFLAGS ${LIB_INCL[$LZIP]}" testp.cpp "${LIB_FLAG[$LZIP]}"
  if [ $? -ne 0 ] ; then
    if [ "${LIB_STAT[$LZIP]}" = 'enabled' ] ; then
      # See if there is already a version of ZLIB in CPPTRAJHOME
      LIB_STAT[$LZIP]='specified'
      LIB_HOME[$LZIP]=$CPPTRAJHOME
      LIB_FLAG[$LZIP]=$CPPTRAJHOME/lib/${LIB_STTC[$LZIP]}
      LIB_INCL[$LZIP]="-I$CPPTRAJHOME/include"
      TestProgram $BUILDTESTOPT "  Checking for bundled ZLIB" "$CXX" "$CXXFLAGS ${LIB_INCL[$LZIP]}" testp.cpp "${LIB_FLAG[$LZIP]}"
      if [ $? -ne 0 ] ; then
        CheckRebuild "ZLIB" "${LIB_FLAG[$LZIP]}"
        # See if user would like to get ZLIB
        PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='zlib' \
            SRCDIR=$ZLIB_SRCDIR SRCTAR=$ZLIB_SRCTAR URL=$ZLIB_URL ./get_library.sh $REBUILDOPT $ZLIB_OPTS
        if [ $? -ne 0 ] ; then
          ErrMsg "No ZLIB available. To build without ZLIB specify '-nozlib'."
          exit 1
        fi
        # Test the built ZLIB
        TestProgram "  Checking built ZLIB" "$CXX" "$CXXFLAGS ${LIB_INCL[$LZIP]}" testp.cpp "${LIB_FLAG[$LZIP]}"
      fi
    else
      # ZLIB specified but failed.
      TestProgErr "ZLIB"
    fi
  fi
}

TestHdf5() {
  # First, check if NetCDF has HDF5 support baked in.
  cat > testp.cpp <<EOF
#include <cstdio>
#include "netcdf.h"
void unused() {
  int ncid, varid;
  int dims[1];
  // Create a netcdf4 file
  nc_create("foo.nc", NC_NETCDF4, &ncid);
  // Create a dimension
  dims[1] = 10;
  nc_def_var(ncid, "MyVar", NC_DOUBLE, 1, dims, &varid);
  // Set deflate
  int err = nc_def_var_deflate(ncid, varid, NC_SHUFFLE, 1, 1);
}
int main() { printf("Testing\n"); printf("%s\n",nc_strerror(0)); return 0; }
EOF
  # If netcdf was specified and only the static library is available, need
  # to add extra flags for hdf5.
  nc_requires_hdf5_flags=0
  lhdf5_hl='-lhdf5_hl'
  lhdf5='-lhdf5'
  SetLibDir "${LIB_HOME[$LHDF5]}" "libhdf5_hl.a"
  if [ ! -z "${LIB_HOME[$LHDF5]}" ] ; then
    if [ -f "${LIB_HOME[$LHDF5]}/$LIBDIR/libhdf5_hl.a" ] ; then
      lhdf5_hl=${LIB_HOME[$LHDF5]}/$LIBDIR/libhdf5_hl.a
    fi
    if [ -f "${LIB_HOME[$LHDF5]}/$LIBDIR/libhdf5.a" ] ; then
      lhdf5=${LIB_HOME[$LHDF5]}/$LIBDIR/libhdf5.a
    fi
  fi
  if [ "${LIB_STAT[$LNETCDF]}" = 'specified' ] ; then
    export LD_LIBRARY_PATH="${LIB_HOME[$LNETCDF]}/lib:$LD_LIBRARY_PATH"
    SetLibDir "${LIB_HOME[$LNETCDF]}" "libnetcdf.a"
    if [ ! -f "${LIB_HOME[$LNETCDF]}/$LIBDIR/libnetcdf.so" -a -f "${LIB_HOME[$LNETCDF]}/$LIBDIR/libnetcdf.a" ] ; then
      #echo "DEBUG: Only static NetCDF library is present."
      nc_requires_hdf5_flags=1
      hdf5_flags="$lhdf5_hl $lhdf5 -ldl ${LIB_FLAG[$LZIP]}"
    fi
  fi
  TestProgram silent "  Checking NetCDF4/HDF5" "$CXX" "$CXXFLAGS ${LIB_INCL[$LNETCDF]}" testp.cpp "${LIB_FLAG[$LNETCDF]} $hdf5_flags"
  if [ $? -eq 0 ] ; then
    # HDF5 support is present.
    # If we are going to build our own netcdf, it needs to know how to link
    # HDF5.
    if [ "${LIB_MAKE[$LNETCDF]}" = 'yes' ] ; then
      LIB_FLAG[$LHDF5]="$ldhf5_hl $lhdf5 -ldl ${LIB_FLAG[$LZIP]}"
    elif [ $nc_requires_hdf5_flags -eq 1 ] ; then
      LIB_FLAG[$LNETCDF]="${LIB_FLAG[$LNETCDF]} $hdf5_flags"
    fi
    return 0
  fi
  # If netcdf was specified, this means netcdf was built without hdf5 support
  if [ "${LIB_STAT[$LNETCDF]}" = 'specified' ] ; then
    ErrMsg "NetCDF in '${LIB_HOME[$LNETCDF]}' does not have HDF5 support."
    ErrMsg "To use this NetCDF, disable HDF5 support with '-nohdf5'."
    exit 1
  fi
  # Check for separate HDF5
  cat > testp.cpp <<EOF
#include <cstdio>
#include "hdf5.h"
void unused() {
  hid_t file;
  file = H5Fcreate("tmp", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
  herr_t status = H5Fclose(file);
}
int main() {
  printf("Testing\n");
  return 0;
}
EOF
  TestProgram silent "  Checking HDF5" "$CXX" "$CXXFLAGS ${LIB_INCL[$LHDF5]}" testp.cpp "${LIB_FLAG[$LHDF5]}"
  if [ $? -ne 0 ] ; then
    if [ "${LIB_STAT[$LHDF5]}" = 'enabled' ] ; then
      # See if there is already a version of HDF5 in CPPTRAJHOME
      SetLibDir "$CPPTRAJHOME" "libhdf5_hl.a"
      LIB_STAT[$LHDF5]='specified'
      LIB_HOME[$LHDF5]=$CPPTRAJHOME
      LIB_FLAG[$LHDF5]="$CPPTRAJHOME/$LIBDIR/libhdf5_hl.a $CPPTRAJHOME/$LIBDIR/${LIB_STTC[$LHDF5]} -ldl ${LIB_FLAG[$LZIP]}"
      LIB_INCL[$LHDF5]="-I$CPPTRAJHOME/include"
      TestProgram $BUILDTESTOPT "  Checking for bundled HDF5" "$CXX" "$CXXFLAGS ${LIB_INCL[$LHDF5]}" testp.cpp "${LIB_FLAG[$LHDF5]}"
      if [ $? -ne 0 ] ; then
        CheckRebuild "HDF5" "${LIB_FLAG[$LHDF5]}"
	# If zlib was specified, pass that to hdf5
        if [ "${LIB_STAT[$LZIP]}" = 'specified' ] ; then
          hdf5zlib="--with-zlib=${LIB_HOME[$LZIP]}"
	else
          hdf5zlib=''
	fi
        # See if user would like to get HDF5 
        PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='hdf5' \
            SRCDIR=$HDF5_SRCDIR SRCTAR=$HDF5_SRCTAR URL=$HDF5_URL ./get_library.sh $REBUILDOPT $HDF5_OPTS $hdf5zlib
        if [ $? -ne 0 ] ; then
          ErrMsg "No HDF5 available. To build without HDF5 specify '-nohdf5'."
          exit 1
        fi
        # Test the built HDF5
        TestProgram "  Checking built HDF5" "$CXX" "$CXXFLAGS ${LIB_INCL[$LHDF5]}" testp.cpp "${LIB_FLAG[$LHDF5]}"
      fi
    else
      # HDF5 specified but failed.
      TestProgErr "HDF5"
    fi
  fi
}

TestNetcdf() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include "netcdf.h"
void unused() {int ncid; nc_open("foo.nc", 0, &ncid);}
int main() { printf("Testing\n"); printf("%s\n",nc_strerror(0)); return 0; }
EOF
  check_netcdf=0
  if [ "${LIB_MAKE[$LNETCDF]}" != 'yes' ] ; then
    TestProgram silent "  Checking NetCDF" "$CXX" "$CXXFLAGS ${LIB_INCL[$LNETCDF]}" testp.cpp "${LIB_FLAG[$LNETCDF]}"
    check_netcdf=$?
    rebuild_netcdf=$REBUILDOPT
  else
    rebuild_netcdf='--rebuild'
  fi
  if [ $check_netcdf -ne 0 -o "${LIB_MAKE[$LNETCDF]}" == 'yes' ] ; then
    SetLibDir "$CPPTRAJHOME" "${LIB_STTC[$LNETCDF]}"
    if [ "${LIB_STAT[$LNETCDF]}" = 'enabled' ] ; then
      # See if there is already a version of NetCDF in CPPTRAJHOME
      LIB_STAT[$LNETCDF]='specified'
      LIB_HOME[$LNETCDF]=$CPPTRAJHOME
      LIB_FLAG[$LNETCDF]=$CPPTRAJHOME/$LIBDIR/${LIB_STTC[$LNETCDF]}
      LIB_INCL[$LNETCDF]="-I$CPPTRAJHOME/include"
      if [ "${LIB_STAT[$LHDF5]}" != 'off' ] ; then
        # Netcdf needs to know where hdf5 is
        LIB_FLAG[$LNETCDF]="${LIB_FLAG[$LNETCDF]} ${LIB_FLAG[$LHDF5]}"
        LIB_INCL[$LNETCDF]="${LIB_INCL[$LNETCDF]} ${LIB_INCL[$LHDF5]}"
      fi
      TestProgram $BUILDTESTOPT "  Checking for bundled NetCDF" "$CXX" "$CXXFLAGS ${LIB_INCL[$LNETCDF]}" testp.cpp "${LIB_FLAG[$LNETCDF]}"
      if [ $? -ne 0 ] ; then
        # Check if lib present but needs to be rebuilt
        CheckRebuild "NetCDF" "${LIB_FLAG[$LNETCDF]}"
        if [ "${LIB_STAT[$LHDF5]}" != 'off' ] ; then
          # Get/compile netcdf4 with HDF5
          # Some of the HDF5-related portions of NetCDF4 have race conditions,
          # so override MAKE_COMMAND
          if [ -z "$MAKE_COMMAND" ] ; then
            echo "Setting MAKE_COMMAND to 'make -j1' to avoid NetCDF4/HDF5 race conditions."
          else
            echo "Overriding MAKE_COMMAND with 'make -j1' to avoid NetCDF4/HDF5 race conditions."
          fi
          PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='netcdf' MAKE_COMMAND='make -j1' \
              CPPFLAGS=${LIB_INCL[$LHDF5]} LDFLAGS="-L$CPPTRAJHOME/$LIBDIR" \
              SRCDIR=$NETCDF_SRCDIR SRCTAR=$NETCDF_SRCTAR URL=$NETCDF_URL ./get_library.sh $rebuild_netcdf $NETCDF4_OPTS
          netcdferr=$?
        else
          # Get/compile netcdf3
          PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='netcdf' \
              SRCDIR=$NETCDF_SRCDIR SRCTAR=$NETCDF_SRCTAR URL=$NETCDF_URL ./get_library.sh $rebuild_netcdf $NETCDF_OPTS
          netcdferr=$?
        fi
        if [ $netcdferr -ne 0 ] ; then
          ErrMsg "No NetCDF available. To build without NetCDF specify '-nonetcdf'"
          exit 1
        fi
        # Test the built netcdf
        TestProgram "  Checking built NetCDF" "$CXX" "$CXXFLAGS ${LIB_INCL[$LNETCDF]}" testp.cpp "${LIB_FLAG[$LNETCDF]}"
      fi
    else
      # NetCDF specified but failed.
      TestProgErr "NetCDF"
    fi
  fi
}

TestPnetcdf() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include <pnetcdf.h>
void unused() {int ncid; ncmpi_open(MPI_COMM_WORLD, "foo.nc", NC_NOWRITE, MPI_INFO_NULL, &ncid);}
int main() { printf("Testing\n"); printf("%s\n",ncmpi_strerror(0)); return 0; }
EOF
  TestProgram silent "  Checking Parallel NetCDF" "$CXX" "$CXXFLAGS ${LIB_INCL[$LPARANC]}" testp.cpp "${LIB_FLAG[$LPARANC]}"
  pnetcdfstat=$?
  # Check if pnetcdf just needs netcdf support
  if [ $pnetcdfstat -ne 0 -a "${LIB_STAT[$LPARANC]}" = 'specified' ] ; then
    TestProgram silent "  Checking Parallel NetCDF (link to NetCDF)" "$CXX" "$CXXFLAGS ${LIB_INCL[$LPARANC]} ${LIB_INCL[$LNETCDF]}" testp.cpp "${LIB_FLAG[$LPARANC]} ${LIB_FLAG[$LNETCDF]}"
    pnetcdfstat=$?
    # If above check worked, pnetcdf should be linked OK with netcdf flags
    return 0
    #echo "DEBUG: Returned $?"
  fi
  if [ $pnetcdfstat -ne 0 ] ; then
    if [ "${LIB_STAT[$LPARANC]}" = 'optional' ] ; then
      WrnMsg "Parallel NetCDF test failed. CPPTRAJ will be built without parallel NetCDF."
      LIB_STAT[$LPARANC]='off'
    elif [ "${LIB_STAT[$LPARANC]}" = 'enabled' ] ; then
      # See if there is already a version of parallel netcdf in CPPTRAJHOME
      LIB_STAT[$LPARANC]='specified'
      LIB_HOME[$LPARANC]=$CPPTRAJHOME
      LIB_FLAG[$LPARANC]=$CPPTRAJHOME/lib/${LIB_STTC[$LPARANC]}
      LIB_INCL[$LPARANC]="-I$CPPTRAJHOME/include"
      TestProgram $BUILDTESTOPT "  Checking for bundled parallel NetCDF" "$CXX" "$CXXFLAGS ${LIB_INCL[$LPARANC]}" testp.cpp "${LIB_FLAG[$LPARANC]}"
      if [ $? -ne 0 ] ; then
        CheckRebuild "Pnetcdf" "${LIB_FLAG[$LPARANC]}"
        # See if user would like to get parallel netcdf
        PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='pnetcdf' \
            SRCDIR=$PNETCDF_SRCDIR SRCTAR=$PNETCDF_SRCTAR URL=$PNETCDF_URL ./get_library.sh $REBUILDOPT $PNETCDF_OPTS
        if [ $? -ne 0 ] ; then
          echo "Disabling parallel NetCDF support."
          LIB_STAT[$LPARANC]='off'
        else
          # Test the built parallel netcdf
          TestProgram "  Checking built parallel NetCDF" "$CXX" "$CXXFLAGS ${LIB_INCL[$LPARANC]}" testp.cpp "${LIB_FLAG[$LPARANC]}"
        fi
      fi
    else
      # Parallel NetCDF specified but failed.
      TestProgErr "Pnetcdf"
    fi
  fi
}

DetermineFlink() {
  if [ "$1" = 'silent' ] ; then
    final_opt='silent'
    shift
  else
    final_opt=''
  fi
  desc="$1"
  flibs="$2"
  # Do we already need FLINK?
  if [ $REQUIRES_FLINK -eq 0 ] ; then
    flink_opts="no yes"
  else
    flink_opts="yes"
  fi
  # Go through combinations of FLINK/pthread
  flink_success=0
  for use_flink in $flink_opts ; do
    for use_pthread in no yes ; do
      libs_to_use="$flibs"
      if [ "$use_flink" = 'yes' ] ; then
        libs_to_use="$libs_to_use $FLINK"
      fi
      if [ "$use_pthread" = 'yes' ] ; then
        libs_to_use="$libs_to_use -lpthread"
      fi
      if [ "$use_flink" = 'yes' -a "$use_pthread" = 'yes' ] ; then
        # Final try. Report errors here
        report=$final_opt
      else
        report='quiet'
      fi
      #echo "DEBUG: Testing $desc flink $use_flink pthread $use_pthread $report"
      TestProgram $report "$desc" "$CXX" "$CXXFLAGS" testp.cpp "$libs_to_use"
      if [ $? -eq 0 ] ; then
        # Compile/run worked.
        if [ "$use_flink" = 'yes' ] ; then
          REQUIRES_FLINK=1
        fi
        if [ "$use_pthread" = 'yes' ] ; then
          REQUIRES_PTHREAD=1
        fi
        flink_success=1
        if [ "$report" = 'quiet' ] ; then
          echo "$desc: OK"
        fi
        return 0
      elif [ "$report" = 'silent' ] ; then
        # Final iteration failed
        return 1
      fi
    done
  done
  if [ $flink_success -eq 0 ] ; then
    # Sanity check. Should not make it here.
    echo "Error: Unexpected error in DetermineFlink()."
    exit 1
  fi
  return 0
}

TestMathlib() {
  cat > testp.cpp <<EOF
#include <cstdio>
extern "C" {
  void dsyev_(char*, char*, int&, double*, int&, double*,double*,int&,int&);
  void dgemm_(char*, char*, int&, int&, int&, double&,
              double*, int&, double*, int&, double&, double*, int&);
}
int main() {
  int n_cols = 3, lwork = 102, info;
  double work[102], mat[9], vec[3], alpha = 1.0;
  mat[0] = 1.0; mat[1] = 1.0; mat[2] = 1.0;
  mat[3] = 1.0; mat[4] = 1.0; mat[5] = 1.0;
  mat[6] = 1.0; mat[7] = 1.0; mat[8] = 1.0;
  dsyev_((char*)"V", (char*)"U", n_cols, mat, n_cols, vec, work, lwork, info);
  dgemm_((char*)"N",(char*)"N", n_cols, n_cols, n_cols, alpha,
         mat, n_cols, mat, n_cols, alpha, mat, n_cols);
  printf("Testing\n"); return 0;
}
EOF
  check_lblas=0
  if [ "${LIB_MAKE[$LBLAS]}" != 'yes' ] ; then
    DetermineFlink silent "  Checking LAPACK/BLAS" "${LIB_FLAG[$LLAPACK]} ${LIB_FLAG[$LBLAS]}"
    check_lblas=$?
    rebuild_math=$REBUILDOPT
  else
    rebuild_math='--rebuild'
  fi
  if [ $check_lblas -ne 0 -o "${LIB_MAKE[$LBLAS]}" = 'yes' ] ; then
    if [ "${LIB_STAT[$LBLAS]}" = 'enabled' ] ; then
      if [ "$BLAS_TYPE" = 'openblas' ] ; then
        MATH_SRCDIR=$OPENBLAS_SRCDIR
        MATH_SRCTAR=$OPENBLAS_SRCTAR
        MATH_URL=$OPENBLAS_URL
        MATH_OPTS=$OPENBLAS_OPTS
        MATH_LIBNAME='openblas'
      elif [ "$BLAS_TYPE" = 'other' ] ; then
        MATH_SRCDIR=$LAPACK_SRCDIR
        MATH_SRCTAR=$LAPACK_SRCTAR
        MATH_URL=$LAPACK_URL
        MATH_OPTS=$LAPACK_OPTS
        MATH_LIBNAME='lapack'
        LIB_STAT[$LLAPACK]='specified'
        LIB_HOME[$LLAPACK]=$CPPTRAJHOME
        LIB_FLAG[$LLAPACK]=$CPPTRAJHOME/lib/${LIB_STTC[$LLAPACK]}
        LIB_INCL[$LLAPACK]="-I$CPPTRAJHOME/include"
      else
        # Bundle not supported for this BLAS type
        TestProgErr "LAPACK/BLAS"
      fi
      # See if there is already a version of BLAS in CPPTRAJHOME
      LIB_STAT[$LBLAS]='specified'
      LIB_HOME[$LBLAS]=$CPPTRAJHOME
      LIB_FLAG[$LBLAS]=$CPPTRAJHOME/lib/${LIB_STTC[$LBLAS]}
      LIB_INCL[$LBLAS]="-I$CPPTRAJHOME/include"
      DetermineFlink $BUILDTESTOPT "  Checking for bundled LAPACK/BLAS" "${LIB_FLAG[$LLAPACK]} ${LIB_FLAG[$LBLAS]}"
      #TestProgram silent "  Checking for bundled OpenBLAS" "$CXX" "$CXXFLAGS ${LIB_INCL[$LBLAS]}" testp.cpp "${LIB_FLAG[$LBLAS]}"
      if [ $? -ne 0 ] ; then
        # Check if lib present but needs to be rebuilt
        CheckRebuild "LAPACK/BLAS" "${LIB_FLAG[$LBLAS]}"
        # See if user would like to get blas
        PREFIX=$CPPTRAJHOME CC="$CC" CFLAGS="$CFLAGS" FC="$FC" FFLAGS="$F77FLAGS" FFLAGS_NOOPT="$F77FLAGS_NOOPT" LIBNAME="$MATH_LIBNAME" \
            SRCDIR=$MATH_SRCDIR SRCTAR=$MATH_SRCTAR URL=$MATH_URL ./get_library.sh $rebuild_math $MATH_OPTS
        if [ $? -ne 0 ] ; then
          ErrMsg "No LAPACK/BLAS available. To build without LAPACK/BLAS specify '-nomathlib'."
          exit 1
        fi
        # Test the built openblas
        DetermineFlink "  Checking built LAPACK/BLAS" "${LIB_FLAG[$LLAPACK]} ${LIB_FLAG[$LBLAS]}"
        #TestProgram "  Checking built OpenBLAS" "$CXX" "$CXXFLAGS ${LIB_INCL[$LBLAS]}" testp.cpp "${LIB_FLAG[$LBLAS]}"
      fi
    else
      # BLAS specified but failed.
      TestProgErr "LAPACK/BLAS"
    fi
  fi
}

TestArpack() {
  cat > testp.cpp <<EOF
#include <cstdio>
extern "C" {
  void dsaupd_(int&, char&, int&, char*, int&, double&, double*,
               int&, double*, int&, int*, int*, double*, double*,
               int&, int&);
}
int main() {
  int ival = 0;
  double dval = 0.0;
  char cval = 'I';
  dsaupd_(ival, cval, ival, &cval, ival, dval, &dval,
          ival, &dval, ival, &ival, &ival, &dval, &dval,
          ival, ival);
  printf("Testing\n"); return 0;
}
EOF
  DetermineFlink "  Checking ARPACK" "${LIB_FLAG[$LARPACK]} ${LIB_FLAG[$LLAPACK]} ${LIB_FLAG[$LBLAS]}"
  if [ $? -ne 0 ] ; then
    TestProgErr "ARPACK"
  fi
}

TestFFTW3() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include <fftw3.h>
int main() {
  fftw_complex* array = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * 32);
  if (array == 0) return 1;
  fftw_free(array);
  printf("Testing\n"); return 0;
}
EOF
   if [ "${LIB_STAT[$LFFTW3]}" = 'amberopt' ] ; then
    # Using FFTW from AMBER
    TestProgram silent "  Checking for FFTW3 from AMBERHOME" "$CXX" "$CXXFLAGS ${LIB_INCL[$LFFTW3]}" testp.cpp "${LIB_FLAG[$LFFTW3]}"
    if [ $? -eq 1 ] ; then
      WrnMsg "FFTW3 test failed. CPPTRAJ will be built without FFTW3."
      LIB_STAT[$LFFTW3]='off'
    fi
  elif [ "$MKL_FFTW" = 'yes' ] ; then
    # Using FFTW from MKL
    TestProgram "  Checking MKL FFTW3" "$CXX" "$CXXFLAGS ${LIB_INCL[$LBLAS]}" testp.cpp "${LIB_FLAG[$LBLAS]}"
  else
    TestProgram silent "  Checking FFTW3" "$CXX" "$CXXFLAGS ${LIB_INCL[$LFFTW3]}" testp.cpp "${LIB_FLAG[$LFFTW3]}"
    if [ $? -ne 0 ] ; then
      if [ "${LIB_STAT[$LFFTW3]}" = 'optional' ] ; then
        WrnMsg "FFTW test failed. CPPTRAJ will use the built-in PubFFT routines."
        if [ $BUILD_LIBS -eq 1 ] ; then
          echo "To force CPPTRAJ to build its own FFTW, reconfigure and specify '--buildlibs'."
        fi
        LIB_STAT[$LFFTW3]='off'
      elif [ "${LIB_STAT[$LFFTW3]}" = 'enabled' ] ; then
        # See if there is already a version of FFTW in CPPTRAJHOME
        LIB_STAT[$LFFTW3]='specified'
        LIB_HOME[$LFFTW3]=$CPPTRAJHOME
        LIB_FLAG[$LFFTW3]=$CPPTRAJHOME/lib/${LIB_STTC[$LFFTW3]}
        LIB_INCL[$LFFTW3]="-I$CPPTRAJHOME/include"
        TestProgram $BUILDTESTOPT "  Checking for bundled FFTW" "$CXX" "$CXXFLAGS ${LIB_INCL[$LFFTW3]}" testp.cpp "${LIB_FLAG[$LFFTW3]}"
        if [ $? -ne 0 ] ; then
          CheckRebuild "FFTW" "${LIB_FLAG[$LFFTW3]}"
          # See if user would like to get FFTW
          PREFIX=$CPPTRAJHOME CC=$CC CFLAGS=$CFLAGS LIBNAME='fftw' \
              SRCDIR=$FFTW_SRCDIR SRCTAR=$FFTW_SRCTAR URL=$FFTW_URL ./get_library.sh $REBUILDOPT $FFTW_OPTS
          if [ $? -ne 0 ] ; then
            # Use built-in FFTW
            WrnMsg "No FFTW available. Using built-in FFT library (does not support PME)."
            LIB_STAT[$LFFTW3]='off'
          else
            # Test the built FFTW
            TestProgram "  Checking built FFTW" "$CXX" "$CXXFLAGS ${LIB_INCL[$LFFTW3]}" testp.cpp "${LIB_FLAG[$LFFTW3]}"
          fi
        fi
      else
        # FFTW specified but failed.
        TestProgErr "FFTW"
      fi
    fi
  fi
}

TestReadline() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include <readline/readline.h>
static char *line_read = (char *)NULL;
// Do not want to actually run this so leave outside main
void Unused() { line_read = readline(""); }
int main() { return 0; }
EOF

  if [ "${LIB_STAT[$LREADLINE]}" = 'specified' ] ; then
    TestProgram "  Checking Readline" "$CXX" "$CXXFLAGS ${LIB_INCL[$LREADLINE]}" testp.cpp "${LIB_FLAG[$LREADLINE]}"
  else
    # Test with just -lreadline
    TestProgram silent "  Checking Readline" "$CXX" "$CXXFLAGS ${LIB_INCL[$LREADLINE]}" testp.cpp "${LIB_FLAG[$LREADLINE]}"
    lreadline_err=$?
    if [ $lreadline_err -ne 0 ] ; then
      # Try -ltermcap
      TestProgram silent "  Checking Readline with termcap" "$CXX" "$CXXFLAGS ${LIB_INCL[$LREADLINE]}" testp.cpp "${LIB_FLAG[$LREADLINE]} -ltermcap"
      lreadline_err=$?
      if [ $lreadline_err -eq 0 ] ; then
        LIB_FLAG[$LREADLINE]="${LIB_FLAG[$LREADLINE]} -ltermcap"
      fi
    fi
    if [ $lreadline_err -ne 0 ] ; then
      # Try -lncurses
      TestProgram silent "  Checking Readline with ncurses" "$CXX" "$CXXFLAGS ${LIB_INCL[$LREADLINE]}" testp.cpp "${LIB_FLAG[$LREADLINE]} -lncurses"
      lreadline_err=$?
      if [ $lreadline_err -eq 0 ] ; then
        LIB_FLAG[$LREADLINE]="${LIB_FLAG[$LREADLINE]} -lncurses"
      fi
    fi
    if [ $lreadline_err -ne 0 ] ; then
      echo "No readline available; using bundled readline."
      LIB_STAT[$LREADLINE]='bundled'
      LIB_FLAG[$LREADLINE]='readline/libreadline.a'
      LIB_INCL[$LREADLINE]='-I.'
    fi
  fi
}

TestXdrfile() {
  cat > testp.cpp <<EOF
#include <xdrfile_xtc.h>
#include <xdr_seek.h>
XDRFILE* file;
bool Unused(const char* fname, int& natoms) {
  if ( read_xtc_natoms( (char*)fname, &natoms ) != exdrOK )
    return false;
  xdr_seek(file, 0, SEEK_SET);
  return true;
}
int main() { return 0; }
EOF
  TestProgram "  Checking Xdrfile" "$CXX" "$CXXFLAGS ${LIB_INCL[$LXDRFILE]}" testp.cpp "${LIB_FLAG[$LXDRFILE]}"
}

TestTngfile() {
  cat > testp.cpp <<EOF
#include <tng/tng_io.h>
tng_trajectory_t traj_;
bool Unused(const char* fname) {
  tng_function_status stat = tng_util_trajectory_open(fname, 'r', &traj_);
  if (stat != TNG_SUCCESS)
    return false;
  return true;
}
int main() { return 0; }
EOF
  TestProgram "  Checking TNG" "$CXX" "$CXXFLAGS ${LIB_INCL[$LTNGFILE]}" testp.cpp "${LIB_FLAG[$LTNGFILE]}"
}

TestSanderlib() {
  cat > testp.cpp <<EOF
#include "sander.h"
int main() {
  sander_input input_;
  input_.extdiel = 78.5; input_.intdiel = 1.0;  input_.rgbmax = 25.0;
  input_.saltcon = 0.0;  input_.cut = 8.0;      input_.dielc = 1.0;
  input_.rdt = 0.0;      input_.fswitch = -1.0; input_.restraint_wt = 0.0;

  input_.igb = 0; input_.alpb = 0;  input_.gbsa = 0;    input_.lj1264 = -1;
  input_.ipb = 0; input_.inp = 2;   input_.vdwmeth = 1; input_.ew_type = 0;
  input_.ntb = 0; input_.ifqnt = 0; input_.jfastw = 0;  input_.ntf = 2;
  input_.ntc = 2; input_.ntr = 0;   input_.ibelly = 0;

  input_.restraintmask[0] = '\0'; input_.bellymask[0] = '\0'; input_.refc[0] = '\0';
  if (is_setup()) sander_cleanup();
  return 0;
}
EOF
  # Check if we can use RPATH syntax. ${LIB_FLAG[$LSANDER]} should
  # always be the complete path to the library.
  lsanderdir=`dirname ${LIB_FLAG[$LSANDER]}`
  for rpath_type in gnu sgi none ; do
    if [ "$rpath_type" = 'gnu' ] ; then
      rpath_line="-L$lsanderdir -lsander -Wl,-rpath,$lsanderdir"
    elif [ "$rpath_type" = 'sgi' ] ; then
      rpath_line="-L$lsanderdir -lsander -rpath $lsanderdir"
    else
      # RPATH does not work.
      # Try no RPATH.
      TestProgram silent "  Checking libsander, no RPATH" "$CXX" "$CXXFLAGS ${LIB_INCL[$LSANDER]}" testp.cpp "${LIB_FLAG[$LSANDER]}"
      if [ $? -ne 0 ] ; then
        if [ "${LIB_STAT[$LSANDER]}" = 'amberopt' ] ; then
          WrnMsg "SANDER test failed. CPPTRAJ will be built without the SANDER API."
          LIB_STAT[$LSANDER]='off'
          break
        else
          echo "SANDER test failed."
          exit 1
        fi
      fi
    fi
    TestProgram silent "  Checking $rpath_type RPATH type for libsander" "$CXX" "$CXXFLAGS ${LIB_INCL[$LSANDER]}" testp.cpp "$rpath_line"
    if [ $? -eq 0 ] ; then
      LIB_FLAG[$LSANDER]="$rpath_line"
      break
    fi
  done # End loop over RPATH types
}

TestCuda() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include <cuda_runtime_api.h>

int main() {
  int device;
  if ( cudaGetDevice( &device ) == cudaSuccess ) {
    cudaDeviceProp deviceProp;
    if ( cudaGetDeviceProperties( &deviceProp, device ) == cudaSuccess )
      printf("| CUDA device: %s\n", deviceProp.name);
  }
  return 0;
}
EOF
  TestProgram noexe "  Checking CUDA" "$CXX" "$CXXFLAGS ${LIB_INCL[$LCUDA]}" testp.cpp "${LIB_FLAG[$LCUDA]}"
}

TestHip() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include <hip/hip_runtime_api.h>

int main() {
  int device;
  if ( hipGetDevice( &device ) == hipSuccess ) {
    hipDeviceProp_t deviceProp;
    if ( hipGetDeviceProperties( &deviceProp, device ) == hipSuccess )
      printf("| HIP device: %s\n", deviceProp.name);
  }
  return 0;
}
EOF
  TestProgram noexe "  Checking HIP" "$CXX" "$CXXFLAGS ${LIB_INCL[$LHIP]} ${LIB_D_ON[$LHIP]}" testp.cpp "${LIB_FLAG[$LHIP]}"
}

TestOpenMM() {
  cat > testp.cpp <<EOF
#include <cstdio>
#include "OpenMM.h"
int main() {
  OpenMM::System*         system = new OpenMM::System();
  system->addParticle(1);
  OpenMM::Integrator*     integrator = new OpenMM::VerletIntegrator(1);
  OpenMM::Context*        context = new OpenMM::Context(*system, *integrator);
  if (system == 0 || integrator == 0 || context == 0) return 1;
  delete system;
  delete integrator;
  delete context;
  return 0;
}
EOF
  TestProgram "  Checking OpenMM" "$CXX" "$CXXFLAGS ${LIB_INCL[$LOPENMM]}" testp.cpp "${LIB_FLAG[$LOPENMM]}"
}

#-------------------------------------------------------------------------------
# Test external libraries
TestLibraries() {
  if [ $BUILD_LIBS -eq 1 ] ; then
    echo "Enabled libraries will be built if not present."
  elif [ -z "$BUILDTESTOPT" ] ; then
    echo "CPPTRAJ will not ask to build libraries if not present."
  fi
  if [ "${LIB_TEST[$LBZIP]}" = 'yes'     ] ; then TestBzlib ; fi
  if [ "${LIB_TEST[$LZIP]}" = 'yes'      ] ; then TestZlib ; fi
  if [ "${LIB_TEST[$LHDF5]}" = 'yes'     ] ; then TestHdf5 ; fi
  if [ "${LIB_TEST[$LNETCDF]}" = 'yes'   ] ; then TestNetcdf ; fi
  if [ "${LIB_TEST[$LPARANC]}" = 'yes'   ] ; then TestPnetcdf ; fi
  if [ "${LIB_TEST[$LBLAS]}" = 'yes'     ] ; then TestMathlib ; fi
  if [ "${LIB_TEST[$LARPACK]}" = 'yes'   ] ; then TestArpack ; fi
  if [ "${LIB_TEST[$LFFTW3]}" = 'yes'    ] ; then TestFFTW3 ; fi
  if [ "${LIB_TEST[$LREADLINE]}" = 'yes' ] ; then TestReadline ; fi
  if [ "${LIB_TEST[$LXDRFILE]}" = 'yes'  ] ; then TestXdrfile ; fi
  if [ "${LIB_TEST[$LTNGFILE]}" = 'yes'  ] ; then TestTngfile ; fi
  if [ "${LIB_TEST[$LSANDER]}" = 'yes'   ] ; then TestSanderlib ; fi
  if [ "${LIB_TEST[$LCUDA]}" = 'yes'     ] ; then TestCuda ; fi
  if [ "${LIB_TEST[$LHIP]}" = 'yes'      ] ; then TestHip ; fi
  if [ "${LIB_TEST[$LOPENMM]}" = 'yes'   ] ; then TestOpenMM ; fi
}

#-------------------------------------------------------------------------------
# Set final flags for compiling and linking.
SetupFinalFlags() {
  # Basic directives
  if [ $USE_MPI -ne 0            ] ; then DIRECTIVES="$DIRECTIVES -DMPI" ; fi
  if [ $USE_CPPTRAJDEBUG -ne 0   ] ; then DIRECTIVES="$DIRECTIVES -DDEBUG" ; fi
  if [ $USE_SINGLEENSEMBLE -ne 0 ] ; then DIRECTIVES="$DIRECTIVES -DENABLE_SINGLE_ENSEMBLE" ; fi
  if [ ! -z "$LFS"               ] ; then DIRECTIVES="$DIRECTIVES $LFS" ; fi
  if [ "$C11_SUPPORT" = 'yes'    ] ; then
    DIRECTIVES="$DIRECTIVES -DC11_SUPPORT"
    if [ "${LIB_STAT[$LFFTW3]}" != 'off' ] ; then
      DIRECTIVES="$DIRECTIVES -DLIBPME -DHAVE_FFTWD=1"
    fi
  fi
  if [ $USE_LEAP_PI -eq 1 ] ; then DIRECTIVES="$DIRECTIVES -DCPPTRAJ_USE_LEAP_PI" ; fi
  # Determine if this is a GitHub or AmberTools build
  if [ ! -z "$AMBERHOME" ] ; then
    AMBCFGDIR=`pwd | grep "AmberTools/src"`
    if [ ! -z "$AMBCFGDIR" ] ; then
      DIRECTIVES="$DIRECTIVES -DBUILDTYPE='\"AmberTools\"'"
      # Attempt to find update_amber
      amber_base_dir=${AMBCFGDIR%"AmberTools/src/cpptraj"}
      update_amber="$amber_base_dir"/updateutils/main.py
      ambertools_major=''
      if [ -f "$update_amber" ] ; then
        ambertools_major=`grep "_AMBERTOOLS_VERSION =" $update_amber | awk '{print $3;}'`
      fi
      if [ ! -z "$ambertools_major" ] ; then
        # Try to determine minor version
        ambertools_minor=0
        at_dir=AmberTools"$ambertools_major"_Applied_Patches
        patch_dir=$amber_base_dir/.patches/$at_dir
        if [ -d "$patch_dir" ] ; then
          update=1
          ufile=$patch_dir/update.$update
          while [ -f "$ufile" ] ; do
            ambertools_minor=$update
            ((update++))
            ufile=$patch_dir/update.$update
          done
          cpptraj_version_string=`printf "V%i.%02i" $ambertools_major $ambertools_minor`
          DIRECTIVES="$DIRECTIVES -DAT_VERSION_STRING='\"$cpptraj_version_string\"'"
        fi
      fi
    else
      DIRECTIVES="$DIRECTIVES -DBUILDTYPE='\"GitHub\"'"
    fi
  else
    # Assume GitHub
    DIRECTIVES="$DIRECTIVES -DBUILDTYPE='\"GitHub\"'"
  fi
  # For GIT, record the current hash
  if [ -f '.git/HEAD' ] ; then
    REFFILE=`awk '{print $2; exit 0;}' .git/HEAD`
    REFFILE=".git/$REFFILE"
    if [ -f "$REFFILE" ] ; then
      HASH=`cat $REFFILE`
      if [ ! -z "$HASH" ] ; then
        DIRECTIVES="$DIRECTIVES -DGITHASH='\"$HASH\"'"
      fi
    fi
  fi
  # Set up include and linking flags
  ldf=''
  CPPTRAJ_LIB=''
  CPPTRAJONLY_LIB=''
  CPPTRAJ_INC=''
  nincl=0
  for ((i=0; i < $NLIB; i++)) ; do
    if [ "${LIB_STAT[$i]}" == 'off' ] ; then
      if [ ! -z "${LIB_DOFF[$i]}" ] ; then
        DIRECTIVES="$DIRECTIVES ${LIB_DOFF[$i]}"
      fi
    else
      if [ ! -z "${LIB_D_ON[$i]}" ] ; then
        DIRECTIVES="$DIRECTIVES ${LIB_D_ON[$i]}"
      fi
      # Include directories
      if [ ! -z "${LIB_INCL[$i]}" ] ; then
        # Search for previous include
        idir=${LIB_INCL[$i]}
        for ((j=0; j < $nincl; j++)) ; do
          if [ "${include_array[$j]}" = "$idir" ] ; then
            # Already included
            #echo "DEBUG: $idir already included"
            idir=''
            break
          fi
        done
        if [ ! -z "$idir" ] ; then
          # Not yet included
          #echo "DEBUG: $idir new inclusion"
          include_array[$nincl]=$idir
          ((nincl++))
          CPPTRAJ_INC="$CPPTRAJ_INC $idir"
        fi
      fi
      # Link flags
      if [ "${LIB_TYPE[$i]}" = 'ld' ] ; then
        ldf="$ldf ${LIB_FLAG[$i]}"
      elif [ "${LIB_TYPE[$i]}" = 'cpp' ] ; then
        CPPTRAJ_LIB="$CPPTRAJ_LIB ${LIB_FLAG[$i]}"
      elif [ "${LIB_TYPE[$i]}" = 'cpptraj' ] ; then
        CPPTRAJONLY_LIB="$CPPTRAJONLY_LIB ${LIB_FLAG[$i]}"
      fi
    fi
  done
  if [ $REQUIRES_FLINK -eq 1 ] ; then
    CPPTRAJ_LIB="$CPPTRAJ_LIB $FLINK"
  fi
  if [ $REQUIRES_PTHREAD -eq 1 ] ; then
    CPPTRAJ_LIB="$CPPTRAJ_LIB -lpthread"
  fi
  LDFLAGS="$ldf $LDFLAGS"
  # Platform-specific directives
  if [ "$PLATFORM" = 'windows' ] ; then
    echo "Warning: DTR trajectory not supported on windows."
  else
    DIRECTIVES="$DIRECTIVES -DENABLE_DTR"
  fi
}

#-------------------------------------------------------------------------------
# Setup include and linker flags for external libraries
SetupLibraries() {
  # Additional BLAS setup if necessary. Done here to override -amberlib.
  if [ "$BLAS_TYPE" = 'none' ] ; then
    LIB_STAT[$LBLAS]='off'
    LIB_STAT[$LLAPACK]='off'
    LIB_STAT[$LARPACK]='off'
  elif [ "$BLAS_TYPE" = 'mkl' ] ; then
    SetupMKL
  elif [ "$BLAS_TYPE" = 'libsci' ] ; then
    LIB_STAT[$LBLAS]='enabled'
    LIB_HOME[$LBLAS]=''
    LIB_LINK[$LBLAS]='dynamic'
    LIB_FLAG[$LBLAS]=''
    LIB_STAT[$LLAPACK]='off'
    LIB_FLAG[$LLAPACK]=''
  elif [ "$BLAS_TYPE" = 'openblas' ] ; then
    if [ "${LIB_STAT[$LBLAS]}" != 'direct' ] ; then
      LIB_FLAG[$LBLAS]='-lopenblas'
    fi
    LIB_STTC[$LBLAS]='libopenblas.a'
    if [ -z "${LIB_HOME[$LBLAS]}" -a "${LIB_STAT[$LBLAS]}" != 'direct' ] ; then
      WrnMsg "'-openblas' may require specifying location with '--with-blas=<DIR>' or '-lblas='"
    fi
    LIB_STAT[$LLAPACK]='off'
    LIB_FLAG[$LLAPACK]=''
  elif [ "$BLAS_TYPE" = 'macAccelerate' ] ; then
    LIB_FLAG[$LBLAS]='-framework Accelerate'
    LIB_STAT[$LLAPACK]='off'
    LIB_FLAG[$LLAPACK]=''
  elif [ $USE_AMBERLIB -eq 1 ] ; then
    if [ "${LIB_STAT[$LBLAS]}" == 'enabled' ] ; then
      echo "  Using blas from $AMBERHOME"
      LIB_STAT[$LBLAS]='specified'
      LIB_HOME[$LBLAS]=$AMBERHOME
      LIB_LINK[$LBLAS]='static'
    fi
    if [ "${LIB_STAT[$LLAPACK]}" == 'enabled' ] ; then
      echo "  Using lapack from $AMBERHOME"
      LIB_STAT[$LLAPACK]='specified'
      LIB_HOME[$LLAPACK]=$AMBERHOME
      LIB_LINK[$LLAPACK]='static'
    fi
  fi
  # Use AMBERHOME to fill in libraries if needed
  if [ $USE_AMBERLIB -eq 1 ] ; then
    if [ "${LIB_STAT[$LNETCDF]}" == 'enabled' ] ; then
      echo "  Using netcdf from $AMBERHOME"
      LIB_STAT[$LNETCDF]='specified'
      LIB_HOME[$LNETCDF]=$AMBERHOME
      LIB_LINK[$LNETCDF]='static'
    fi
    if [ "${LIB_STAT[$LARPACK]}" == 'enabled' -a "$BLAS_TYPE" != 'openblas' ] ; then
      echo "  Using arpack from $AMBERHOME"
      LIB_STAT[$LARPACK]='specified'
      LIB_HOME[$LARPACK]=$AMBERHOME
      LIB_LINK[$LARPACK]='static'
    fi
    if [ "${LIB_STAT[$LFFTW3]}" = 'off' ] ; then
      LIB_STAT[$LFFTW3]='amberopt'
      LIB_LINK[$LFFTW3]='static'
    elif [ "${LIB_STAT[$LFFTW3]}" == 'enabled' ] ; then
      echo "  Using fftw from $AMBERHOME"
      LIB_STAT[$LFFTW3]='specified'
      LIB_HOME[$LFFTW3]=$AMBERHOME
      LIB_LINK[$LFFTW3]='static'
    fi
  fi
  # For any 'amberopt' check that AMBERHOME is available.
  for ((i=0; i < $NLIB; i++)) ; do
    if [ "${LIB_STAT[$i]}" = 'amberopt' ] ; then
      if [ -z "$AMBERHOME" ] ; then
        WrnMsg "Compilation of ${LIB_CKEY[$i]} requires AMBERHOME to be set"
        WrnMsg "  if --with-${LIB_CKEY[$i]} not specified."
        LIB_STAT[$i]='off'
      else
        LIB_HOME[$i]=$AMBERHOME
      fi
    fi
  done
  # Use specified directory to fill in libraries if needed
  if [ ! -z "$SPECIFIED_LIB_DIR" ] ; then
    if [ ! -d "$SPECIFIED_LIB_DIR" ] ; then
      Err "Specified library directory $SPECIFIED_LIB_DIR not found."
    fi
    if [ "${LIB_STAT[$LNETCDF]}" == 'enabled' ] ; then
      echo "  Using netcdf from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LNETCDF]='specified'
      LIB_HOME[$LNETCDF]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LNETCDF]='static'
    fi
    if [ "${LIB_STAT[$LHDF5]}" == 'enabled' ] ; then
      echo "  Using hdf5 from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LHDF5]='specified'
      LIB_HOME[$LHDF5]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LHDF5]='static'
    fi
    if [ "${LIB_STAT[$LARPACK]}" == 'enabled' -a "$BLAS_TYPE" != 'openblas' ] ; then
      echo "  Using arpack from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LARPACK]='specified'
      LIB_HOME[$LARPACK]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LARPACK]='static'
    fi
    if [ "${LIB_STAT[$LFFTW3]}" == 'enabled' ] ; then
      echo "  Using fftw from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LFFTW3]='specified'
      LIB_HOME[$LFFTW3]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LFFTW3]='static'
    fi
    if [ "${LIB_STAT[$LBZIP]}" == 'enabled' ] ; then
      echo "  Using bzip from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LBZIP]='specified'
      LIB_HOME[$LBZIP]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LBZIP]='static'
    fi
    if [ "${LIB_STAT[$LZIP]}" == 'enabled' ] ; then
      echo "  Using zlib from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LZIP]='specified'
      LIB_HOME[$LZIP]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LZIP]='static'
    fi
    if [ "${LIB_STAT[$LZIP]}" == 'enabled' ] ; then
      echo "  Using zlib from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LZIP]='specified'
      LIB_HOME[$LZIP]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LZIP]='static'
    fi
    if [ "${LIB_STAT[$LLAPACK]}" == 'enabled' ] ; then
      echo "  Using lapack from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LLAPACK]='specified'
      LIB_HOME[$LLAPACK]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LLAPACK]='static'
    fi
    if [ "${LIB_STAT[$LBLAS]}" == 'enabled' ] ; then
      echo "  Using blas from $SPECIFIED_LIB_DIR"
      LIB_STAT[$LBLAS]='specified'
      LIB_HOME[$LBLAS]=$SPECIFIED_LIB_DIR
      #LIB_LINK[$LBLAS]='static'
    fi
  fi
  # Set up library paths
  for ((i=0; i < $NLIB; i++)) ; do
    lhome=''
    linc=''
    lflag=''
    #echo "DEBUG: ${LIB_CKEY[$i]} flag=${LIB_FLAG[$i]} stat=${LIB_STAT[$i]} home=${LIB_HOME[$i]}"
    if [ "${LIB_STAT[$i]}" = 'off' ] ; then
      #echo "${LIB_CKEY[$i]} disabled." # DEBUG
      LIB_TEST[$i]='no'
    else
      #echo "${LIB_CKEY[$i]} enabled." # DEBUG
      # Static/dynamic linking
      if [ "${LIB_STAT[$i]}" = 'specified' -a $USE_STATIC -eq 2 ] ; then
        LIB_LINK[$i]='static'
      fi
      lhome=${LIB_HOME[$i]}
      #echo DEBUG $lhome ${LIB_STAT[$i]}
      if [ "${LIB_STAT[$i]}" = 'bundled' ] ; then
        LIB_TEST[$i]='no'
        linc="-I$lhome"
        lflag="$lhome/${LIB_STTC[$i]}"
      else
        LIB_TEST[$i]=$PERFORM_CHECKS
        if [ "${LIB_STAT[$i]}" = 'direct' ] ; then
          lflag=${LIB_FLAG[$i]}
          linc=''
        elif [ -z "$lhome" ] ; then
          # Lib home not specified
          if [ "${LIB_LINK[$i]}" = 'static' ] ; then
            Err "'-libstatic' requires --with-${LIB_CKEY[$i]} specified."
          fi
          lflag=${LIB_FLAG[$i]}
        else
          # Lib home specified.
          # Determine include directory.
          incdir="$lhome/include"
          linc="-I$incdir"
          if [ ! -d "$incdir" ] ; then
            # include dir is not in the usual place, happens with e.g. some CUDA installs.
            if [ -d "$lhome/targets/x86_64-linux/include" ] ; then
              linc="-I$lhome/targets/x86_64-linux/include"
            else
              WrnMsg "Include dir $incdir not found. Linking ${LIB_CKEY[$i]} may fail."
            fi
          fi
          # Check if architecture-specific lib dir exists. Use that if so.
          lhdir="$lhome/lib"
          ladir="$lhome/lib$NBITS"
          if [ -d "$ladir" ] ; then
            lhdir="$ladir"
          fi
          if [ "${LIB_LINK[$i]}" = 'static' ] ; then
            if [ -z "${LIB_STTC[$i]}" -o ! -f "$lhdir/${LIB_STTC[$i]}" ] ; then
              WrnMsg "Cannot link '${LIB_CKEY[$i]}' statically."
              lflag="-L$lhdir ${LIB_FLAG[$i]}"
            else
              lflag="$lhdir/${LIB_STTC[$i]}"
            fi
          else
            lflag="-L$lhdir ${LIB_FLAG[$i]}"
          fi
          # Library-specific CPPTRAJ_INC fixes when home specified.
          #if [ $i -eq $LREADLINE ] ; then
          #  linc="$linc/readline"
          #fi
          if [ $i -eq $LXDRFILE ] ; then
            linc="$linc/xdrfile"
          fi
        fi
        # Library-specific flag fixes
#        if [ $i -eq $LREADLINE ] ; then
          # For external readline, we need to link libtermcap for windows
          # and libncurses for Linux
          #if [ $USE_WINDOWS -eq 1 ]; then
#            lflag="$lflag -ltermcap"
          #else
          #  lflag="$lflag -lncurses"
          #fi
#        elif [ $i -eq $LSANDER ] ; then
        if [ $i -eq $LSANDER ] ; then
          # Always specify libsander location to prevent pulling in
          # other amber libraries.
          if [ ! -f "${LIB_FLAG[$LSANDER]}" ] ; then
            lflag="${LIB_HOME[$LSANDER]}/lib/libsander$SHARED_SUFFIX"
          else
            # libsander directly specified.
            lflag=${LIB_FLAG[$LSANDER]}
            # Figure out the include directory
            if [ -z "$linc" ] ; then
              tmpdir1=`dirname $lflag`   # the lib dir
              tmpdir2=`dirname $tmpdir1` # The AMBERHOME dir
              linc="-I"$tmpdir2/include
            fi
          fi
        fi
      fi
      # Special case. If library had include path set already, do not override it.
      if [ ! -z "${LIB_INCL[$i]}" ] ; then
        linc=${LIB_INCL[$i]}
      fi
      #echo "DEBUG lib ${LIB_CKEY[$i]} stat=\"${LIB_STAT[$i]}\" linc=\"$linc\" lflag=\"$lflag\"" # DEBUG
      LIB_FLAG[$i]="$lflag"
      LIB_INCL[$i]="$linc"
    fi
  done
  # Take care of any library dependencies.
  if [ "${LIB_STAT[$LZIP]}" = 'off' -a "${LIB_STAT[$LTNGFILE]}" != 'off' ] ; then
    # TNG depends on libz
    echo "Warning: TNG depends on libz; disabling TNG."
    LIB_STAT[$LTNGFILE]='off'
  fi
  if [ "${LIB_STAT[$LNETCDF]}" = 'off' -a "${LIB_STAT[$LHDF5]}" != 'off' ] ; then
    # HDF5 needs netcdf
    echo "Warning: HDF5 depends on NetCDF; disabling HDF5."
    LIB_STAT[$LHDF5]='off'
    LIB_TEST[$LHDF5]='no'
  fi
}

#-------------------------------------------------------------------------------
# Check compiler version.
CheckCompilerVersion() {
  c_compiler=$1
  basecc=`basename $c_compiler`
  # Use -v
  cc_version=`$c_compiler -v 2>&1 | grep -E "$basecc |[vV]ersion " \
                  | sed -e 's/Open64//' -e 's/(.*)//' -e 's/^[a-zA-Z :]* //' -e 's/ .*//'`
  if [ -z "$cc_version" ] ; then
     echo "Error: $c_compiler is not well formed or produces unusual version details!"
     echo "       Check for a CC environment variable."
     exit 1
  else
     echo "  The version of $c_compiler is $cc_version"
  fi
  # use '.' as only field delimiter.
  cc_version=`echo $cc_version | sed -e 's/-/./'`
  cc_version_major=`echo $cc_version | cut -d'.' -f1`
  cc_version_minor=`echo $cc_version | cut -d'.' -f2`
  cc_version_patch=`echo $cc_version | cut -d'.' -f3`
  #echo "DEBUG: $cc_version $cc_version_major $cc_version_minor $cc_version_patch"
  #exit 1 # DEBUG
}

# Set up compiler commands and compiler options
SetupCompilers() {
  if [ ! -z "$CXX" ] ; then echo "C++ compiler (CXX) set to $CXX" ; fi
  if [ ! -z "$CC"  ] ; then echo "C compiler (CC) set to $CC" ; fi
  if [ ! -z "$FC"  ] ; then echo "Fortran compiler (FC) set to $FC" ; fi
  # If no compiler type specified try to guess
  if [ -z "$COMPILERS" ] ; then
    if [ ! -z "$CXX" ] ; then
      SPECIFIED_COMPILER=$COMPILERS
      echo "Determining compilers from CXX ($CXX)"
      case "$CXX" in
        # NOTE - Have to look for clang++ first since it overlaps with g++
        *clang++* ) COMPILERS='clang' ;;
        *g++*     ) COMPILERS='gnu' ;;
        *icpc*    ) COMPILERS='intel' ;;
        *icpx*    ) COMPILERS='oneapi' ;;
        *pgc++*   ) COMPILERS='pgi' ;;
        *CC*      ) COMPILERS='cray' ;;
        * ) WrnMsg "Could not detect compiler type ($CXX); assuming GNU" ;;
      esac
      # If compiler was also specified make sure it matches as a sanity check
      if [ ! -z "$SPECIFIED_COMPILER" -a "$SPECIFIED_COMPILER" != "$COMPILERS" ] ; then
        WrnMsg "$SPECIFIED_COMPILER compilers specified but need $COMPILERS based on CXX = $CXX"
      fi
    fi
  fi
  # If still no compiler default to gnu
  if [ -z "$COMPILERS" ] ; then
    # On OSX sometimes gnu means clang
    if [ "$PLATFORM" = 'Darwin' -a ! -z "`g++ --version | grep LLVM`" ] ; then
      echo "No compilers specified; defaulting to Apple clang (gnu)"
      COMPILERS='clang'
    else
      echo "No compilers specified; defaulting to gnu"
      COMPILERS='gnu'
    fi
  fi
  # Set compiler options
  optflags=''       # C/C++ compiler optimization flags
  foptflags=''      # Fortran compiler optimization flags
  hostflags=''      # Flags for native host optimizations
  ompflag=''        # Compiler OpenMP flag
  freefmtflag=''    # Fortran free format flag
  picflag=''        # Compiler flag for position-independent code
  warnflag='-Wall'
  fwarnflag=''
  DBFLAG='-g'
  noinlineflag='-fno-inline'
  commonflags=''
  staticflag='-static'
  staticlink=''
  case "$COMPILERS" in
    'gnu' )
      if [ -z "$CC" ]; then CC=gcc; fi
      if [ -z "$CXX" ]; then CXX=g++; fi
      if [ -z "$FC" ]; then FC=gfortran; fi
      hostflags='-mtune=native'
      optflags='-O3'
      ompflag='-fopenmp'
      freefmtflag='-ffree-form'
      foptflags='-O3'
      FLINK='-lgfortran'
      picflag='-fPIC'
      C11FLAG='-std=gnu++11'
      staticlink='-lquadmath'
      # Check compiler version
      CheckCompilerVersion $CC 
      # Set version-specific flags
      if [ $cc_version_major -ge 14 ] ; then
        # Needed for readline with gcc >= 14
        CFLAGS="$CFLAGS -D_DEFAULT_SOURCE -D_XOPEN_SOURCE"
      fi
      ;;
   'clang' )
      if [ -z "$CC" ]; then CC=clang; fi
      if [ -z "$CXX" ]; then CXX=clang++; fi
      if [ -z "$FC" ]; then FC=gfortran; fi
      hostflags=''
      optflags='-O3'
      ompflag='-fopenmp'
      freefmtflag='-ffree-form'
      foptflags='-O3'
      FLINK='-lgfortran'
      picflag='-fPIC'
      C11FLAG='-std=c++11'
      # Check the GNU compiler version
      CheckCompilerVersion gcc
      # Set version-specific flags
      if [ $cc_version_major -ge 13 ] ; then
        # Needed for readline with gcc >= 13
        CFLAGS="$CFLAGS -D_DEFAULT_SOURCE -D_XOPEN_SOURCE"
      fi
      ;;
   'oneapi' )
      if [ -z "$CC" ]; then CC=icx; fi
      if [ -z "$CXX" ]; then CXX=icpx; fi
      CXXFLAGS="-fp-model precise $CXXFLAGS"
      hostflags=''
      optflags=''
      ompflag='-fopenmp'
      picflag='-fpic'
      C11FLAG='-std=c++11'
      # May be several fortran compiler options
      if [ -z "$FC" ]; then
        if [ ! -z "`which ifx`" ] ; then
          FC=ifx
        elif [ ! -z "`which ifort`" ] ; then
          FC=ifort
        else
          FC=gfortran
        fi
      fi
      # Determine flags based on what fortran we have
      if [ "$FC" = 'gfortran' ] ; then
        freefmtflag='-ffree-form'
        foptflags='-O3'
        FLINK='-lgfortran'
      elif [ "$FC" = 'ifort' ] ; then
        freefmtflag='-FR'
        foptflags='-ip -O3'
        fwarnflag='-warn all'
        FLINK='-lifport -lifcore'
      elif [ "$FC" = 'ifx' ] ; then
        fwarnflag='-warn all'
        FLINK='-lifport -lifcore'
      fi
      ;;
    'intel' )
      if [ -z "$CC" ]; then CC=icc; fi
      if [ -z "$CXX" ]; then CXX=icpc; fi
      if [ -z "$FC" ]; then FC=ifort; fi
      CXXFLAGS="-fp-model precise -fp-model source $CXXFLAGS"
      CFLAGS="-fp-model precise -fp-model source $CFLAGS"
      hostflags='-xHost'
      optflags='-O3'
      VERSION_LINE=`$CXX -v 2>&1 | grep version`
      if [ $? -ne 0 ] ; then
        echo "$VERSION_LINE"
        Err "Could not check Intel C++ compiler version."
      fi
      MAJOR_V=`echo "$VERSION_LINE" | awk '{print $3; exit 0;}' | cut -d'.' -f1`
      if [ $MAJOR_V -ge 16 ] ; then
        ompflag='-qopenmp'
      else
        ompflag='-openmp'
      fi
      freefmtflag='-FR'
      foptflags='-ip -O3'
      fwarnflag='-warn all'
      FLINK='-lifport -lifcore'
      picflag="-fpic"
      C11FLAG='-std=c++11'
      # Check for 'error: identifier "_LIB_VERSION_TYPE" is undefined'
      cat > testp.cpp <<EOF
#include <math.h>
int main() { double x; x = sqrt(2); return 0; }
EOF
      TestProgram quiet "  Testing Intel compatibility with C headers" "$CXX" "$CXXFLAGS" testp.cpp
      if [ $? -ne 0 ] ; then
        CFLAGS="-D__PURE_INTEL_C99_HEADERS__ $CFLAGS"
        CXXFLAGS="-D__PURE_INTEL_C99_HEADERS__ $CXXFLAGS"
      fi
      ;;
    "pgi" )
      if [ -z "$CC" ]; then CC=pgcc; fi
      if [ -z "$CXX" ]; then CXX=pgc++; fi
      if [ -z "$FC" ]; then FC=pgf90; fi
      CXXFLAGS="-Kieee -Mnoflushz $CXXFLAGS"
      CFLAGS="-Kieee -Mnoflushz $CFLAGS"
      hostflags='-fastsse'
      optflags='-fast'
      foptflags='-fast'
      if [ "$PLATFORM" = 'cray' ] ; then
        ompflag='-mp=nonuma'
      else
        ompflag='-mp'
      fi
      noinlineflag='-Mnoautoinline'
      warnflag='-Minform=warn'
      freefmtflag='-Mfree'
      FLINK='-pgf90libs'
      picflag='-fpic'
      C11FLAG='-std=c++11'
      ;;
    "cray" )
      if [ -z "$CC" ]; then CC=cc; fi
      if [ -z "$CXX" ]; then CXX=CC; fi
      if [ -z "$FC" ]; then FC=ftn; fi
      CXXFLAGS="-h gnu $CXXFLAGS"
      CFLAGS="-h gnu $CFLAGS"
      hostflags=''
      optflags=''
      ompflag=''
      warnflag='-h msglevel_2' # This will also print cautions
      fwarnflag='-m 2'
      freefmtflag='-f free -emf'
      foptflags=''
      FLINK=''
      picflag='-fpic'
      C11FLAG='-hstd=c++11'
      if [ $USE_OPENMP -eq 0 ] ; then
        commonflags='-h noomp'
      fi
      ;;
    * ) Err "Unknown compilers: $1" ;;
  esac
  # Unless specified fortran warnflag is same as C/C++
  if [ -z "$fwarnflag" ] ; then fwarnflag=$warnflag ; fi

  # Turn off/on optimizations if necessary
  if [ ! -z "$TUNEFLAGS" ] ; then
    USE_OPT=2
    hostflags=$TUNEFLAGS
  fi
  if [ $USE_OPT -eq 0 ] ; then
    optflags='-O0'
    foptflags='-O0'
    hostflags=''
  elif [ $USE_OPT -eq 2 ] ; then
    optflags="$optflags $hostflags"
    foptflags="$foptflags $hostflags"
  fi
  # Turn off PI code if necessary
  if [ $USE_SHARED -eq 0 ] ; then
    picflag=''
  fi
  # Turn off debug flags if necessary
  if [ $USE_DEBUG -eq 0 ] ; then
    DBFLAG=''
    noinlineflag=''
  fi
  # Turn off static flag if necessary
  if [ $USE_STATIC -ne 1 ] ; then
    staticflag=''
    staticlink=''
  fi
  # Turn off openmp flag if necessary
  if [ $USE_OPENMP -eq 0 ] ; then
    ompflag=''
  fi
  # Set compiler flags
  CXXFLAGS="$DBFLAG $warnflag $ompflag $optflags $noinlineflag $picflag $commonflags $CXXFLAGS"
  CFLAGS="$DBFLAG $warnflag $ompflag $optflags $picflag $commonflags $CFLAGS"
  F77FLAGS_NOOPT="$DBFLAG $fwarnflag $ompflag -O0 $picflag $commonflags $F77FLAGS"
  F77FLAGS="$DBFLAG $fwarnflag $ompflag $foptflags $picflag $commonflags $F77FLAGS"
  FFLAGS="$DBFLAG $fwarnflag $ompflag $foptflags $picflag $freefmtflag $commonflags $FFLAGS"
  LDFLAGS="$LDFLAGS $ompflag $staticflag $staticlink"
  # DEBUG
  #echo $CXX $CXXFLAGS
  #echo $CC $CFLAGS
  #echo $FC $FFLAGS

  # Build MPI if requested
  if [ ! -z "$BUILD_MPI" ] ; then
    BuildMPI $BUILD_MPI
  fi

  # Change to MPI compiler wrappers if specified. Not needed for cray.
  if [ $USE_MPI -ne 0 -a "$COMPILERS" != 'cray' ] ; then
    if [ $USE_MPI -eq 1 ] ; then
      mpi_cc='mpicc'
      mpi_cxx='mpicxx'
      mpi_f90='mpif90'
    elif [ $USE_MPI -eq 2 ] ; then
      mpi_cc='mpiicc'
      mpi_cxx='mpiicpc'
      mpi_f90='mpiifort'
    fi
    if [ -z "$MPICC" ] ; then
      CC=$mpi_cc
    else
      echo "MPI C compiler (MPICC) set to $MPICC"
      CC=$MPICC
    fi
    if [ -z "$MPICXX" ] ; then
      CXX=$mpi_cxx
    else
      echo "MPI C++ compiler (MPICXX) set to $MPICXX"
      CXX=$MPICXX
    fi
    if [ -z "$MPIF90" ] ; then
      FC=$mpi_f90
    else
      echo "MPI Fortran compiler (MPIF90) set to $MPIF90"
      FC=$MPIF90
    fi
  fi
  # Use cray wrappers
  if [ "$PLATFORM" = 'cray' ] ; then
    CC=cc
    CXX=CC
    FC=ftn
  fi
  # Sanity check
  if [ -z "$CC" -o -z "$CXX" -o -z "$FC" ] ; then
    ErrMsg "No compiler specified and CXX not set."
    UsageSimple
    exit 1
  fi
}

#-------------------------------------------------------------------------------
# Set up profiling if specified
SetupProfiling() {
  if [ $USE_PROFILE -ne 0 ] ; then
    if [ $USE_PROFILE -eq 1 -o $USE_PROFILE -eq 2 ] ; then
      if [ "$COMPILERS" != 'gnu' ] ; then
        Err "This profile option only supported by GNU compilers."
      fi
      if [ $USE_PROFILE -eq 1 ] ; then
        CXXFLAGS="-pg $CXXFLAGS"
        CFLAGS="-pg $CXXFLAGS"
        LDFLAGS="-pg $LDFLAGS"
      else
        CXXFLAGS="$CXXFLAGS -D_GLIBCXX_PROFILE"
      fi
    elif [ $USE_PROFILE -eq 3 ] ; then
      vtuneflags=''
      if [ "$COMPILERS" = 'intel' ] ; then
        vtuneflags='-debug inline-debug-info'
        CFLAGS="-g $vtuneflags $CFLAGS"
        CXXFLAGS="-g $vtuneflags $CXXFLAGS"
      fi
      LDFLAGS="-shared-intel -shared-libgcc $LDFLAGS"
    fi
  fi
}

#-------------------------------------------------------------------------------
# Basic compiler tests
TestCompilers() {
  echo ""
  # C++ OpenMP
  if [ $USE_OPENMP -eq 1 ] ; then
    cat > testp.cpp <<EOF
#ifdef _OPENMP
#include <omp.h>
#include <cstdio>
int main() {
  int nthreads;
# pragma omp parallel
  {
  if (omp_get_thread_num() == 0)
    nthreads = omp_get_num_threads();
  }
  printf("%i threads Testing\n", nthreads);
  return 0;
}
#endif
EOF
    TestProgram "  Testing C++ compiler (OpenMP)" "$CXX" "$CXXFLAGS" testp.cpp
  else
  # C++
    cat > testp.cpp <<EOF
#include <cstdio>
int main() { printf("Testing\n"); return 0; }
EOF
    TestProgram "  Testing C++ compiler" "$CXX" "$CXXFLAGS" testp.cpp
  fi
  # C
  cat > testp.c <<EOF
#include <stdio.h>
int main() { printf("Testing\n"); return 0; }
EOF
  TestProgram "  Testing C compiler" "$CC" "$CFLAGS" testp.c
  # Fortran - only needed if pub_fft.F90 needs to be compiled
  if [ $REQUIRES_FLINK -eq 1 ] ; then
    cat > testp.f <<EOF
      program testf
      write(6,*) 'testing a Fortran program'
      end program testf
EOF
    TestProgram "  Testing Fortran compiler" "$FC" "$FFLAGS" testp.f
#    # Test C++/Fortran linking
#    cat > testp.cpp <<EOF
#extern "C" { void printmessage(int&); }
#int main() { int ival = 1; printmessage( ival ); return 0; }
#EOF
#    cat > testp.f <<EOF
#      subroutine printmessage(ival)
#      integer ival
#      write(6,'(a,i6)') "Ival is ", ival
#      end subroutine printmessage
#EOF
#    echo "  Testing C++/Fortran linking"
#    echo "$CXX $CXXFLAGS -c -o testp.cpp.o testp.cpp"
##    $CXX $CXXFLAGS -c -o testp.cpp.o testp.cpp
#    echo "$FC $FFLAGS -c -o testp.f.o testp.f"
#    $FC $FFLAGS -c -o testp.f.o testp.f
  fi
}

# ------------------------------------------------------------------------------
# Set up MKL flags for BLAS/LAPACK
SetupMKL() {
  if [ "$MKL_TYPE" = 'mkl' -a "$COMPILERS" != 'intel' ] ; then
     MKL_TYPE='line'
  fi
  # Determine mkl home directory
  mklroot=''
  if [ ! -z "$MKLROOT" ] ; then
    mklroot=$MKLROOT
  elif [ ! -z "$MKL_HOME" ] ; then
    mklroot=$MKL_HOME
  fi
  if [ ! -z "$mklroot" ] ; then
    echo "  Using MKL for BLAS/LAPACK in $mklroot"
  fi
  # Determine link style
  if [ "$MKL_TYPE" = 'mkl' ] ; then
    # Simple flag for Intel compilers
    mkllib='-mkl'
  else
    # Link-line advisor style
    if [ -z "$mklroot" ] ; then
      Err "MKLROOT/MKL_HOME not set."
    fi
    mkldir=$mklroot
    # Platform-dependent stuff
    if [ "$PLATFORM" = 'Darwin' ] ; then
      mkldir="$mkldir/lib"
      wlstart=''
      wlend=''
    else
      if [ "$NBITS" -eq 64 ] ; then
        mkldir="$mkldir/lib/intel64"
      else
        mkldir="$mkldir/lib/32"
      fi
      wlstart='-Wl,--start-group'
      wlend='-Wl,--end-group'
    fi
    # Determine architecture
    if [ "$NBITS" -eq 64 ] ; then
      mklinterface=libmkl_intel_lp64.a
      mklblas="-lmkl_blas95_lp64"
      mkllapack="-lmkl_lapack95_lp64"
    else
      mklinterface=libmkl_intel.a
      mklblas="-lmkl_blas95"
      mkllapack="-lmkl_lapack95"
    fi
    # Assume GNU linker.
    mklthread=''
    mklomp=''
    if [ $USE_OPENMP -eq 1 ] ; then
      if [ "$COMPILERS" = 'intel' ] ; then
        mklthread="$mkldir/libmkl_intel_thread.a"
        mklomp='-liomp5'
      elif [ "$COMPILERS" = 'pgi' ] ; then
        mklthread="$mkldir/libmkl_pgi_thread.a"
        mklomp='-pgf90libs -mp'
      elif [ "$COMPILERS" = 'gnu' ] ; then
        mklthread="$mkldir/libmkl_gnu_thread.a"
        mklomp='-lgomp'
      else
        WrnMsg "OpenMP MKL not supported for $COMPILERS. Using sequential."
        mklthread="$mkldir/libmkl_sequential.a"
      fi
      if [ "$PLATFORM" = 'Darwin' -a "$COMPILERS" != 'intel' ] ; then
        WrnMsg "OpenMP MKL not supported on OSX without Intel compilers. Using sequential."
        mklthread="$mkldir/libmkl_sequential.a"
      fi
    else
      mklthread="$mkldir/libmkl_sequential.a"
    fi
    # Create the link line
    mkllib="-L$mkldir $mkllapack $mklblas $wlstart $mkldir/$mklinterface $mklthread $mkldir/libmkl_core.a $wlend $mklomp -lpthread -lm -ldl"
    # Turn off pthread since we are adding it here.
    REQUIRES_PTHREAD=0
  fi
  LIB_STAT[$LBLAS]='enabled'
  LIB_HOME[$LBLAS]=''
  LIB_LINK[$LBLAS]='dynamic'
  LIB_FLAG[$LBLAS]="$mkllib"
  LIB_STAT[$LLAPACK]='off'
  LIB_FLAG[$LLAPACK]=''
  # If no FFTW, try using MKL
  if [ "$MKL_FFTW" != 'no' ] ; then
    if [ "${LIB_STAT[$LFFTW3]}" = 'off' -o "${LIB_STAT[$LFFTW3]}" = 'optional' -o "${LIB_STAT[$LFFTW3]}" = 'enabled' ] ; then
      MKL_FFTW='yes'
      LIB_STAT[$LFFTW3]='enabled'
      LIB_FLAG[$LFFTW3]=''
      if [ ! -z "$mklroot" ] ; then
        LIB_INCL[$LBLAS]="-I$mklroot/include/fftw"
      fi
    fi
  fi
}
# ------------------------------------------------------------------------------
# Define different shader models/compute architectures and their CUDA limits
# CUDA version
#  3.0-3.1    ...
#  3.2        .........
#  4.0-4.2    .........
#  5.X        ...........................
#  6.0        ...........................
#  6.5        ...................................................
#  7.X        ...................................................
#  8.X        .....................................................................
#  9.X                    .....................................................................
# 10.X                    ...........................................................................
# 11.0                                .......................................................................
# 11.1-11.4                           .............................................................................
# 11.5-11.7.1                         ..................................................................................
# 11.8                                .........................................................................................
# 12.0-12.6                                       ..................................................................................
# 12.8                                            ..........................................................................................
# 12.9                                            .................................................................................................
CUDA_SM_LIST='sm_20 sm_21 sm_30 sm_32 sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86 sm_87 sm_89 sm_90 sm_120 sm_121'

# SetSupportedSM <major v> <minor v>
# Set Shader models supported by current cuda version
SetSupportedSM() {
  if [ $1 -lt 3 ] ; then
    Err "CUDA < 3 not supported."
  fi
  if [ $1 -eq 3 ] ; then
    if [ $2 -ge 2 ] ; then
      CUDA_SM_LIST='sm_20 sm_21'
    else
      CUDA_SM_LIST='sm_20'
    fi
  elif [ $1 -eq 4 ] ; then
    CUDA_SM_LIST='sm_20 sm_21'
  elif [ $1 -eq 5 ] ; then
    CUDA_SM_LIST='sm_20 sm_21 sm_30 sm_32 sm_35'
  elif [ $1 -eq 6 ] ; then
    if [ $2 -ge 5 ] ; then
      CUDA_SM_LIST='sm_20 sm_21 sm_30 sm_32 sm_35 sm_37 sm_50 sm_52 sm_53'
    else
      CUDA_SM_LIST='sm_20 sm_21 sm_30 sm_32 sm_35'
    fi
  elif [ $1 -eq 7 ] ; then
    CUDA_SM_LIST='sm_20 sm_21 sm_30 sm_32 sm_35 sm_37 sm_50 sm_52 sm_53'
  elif [ $1 -eq 8 ] ; then
    CUDA_SM_LIST='sm_20 sm_21 sm_30 sm_32 sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62'
  elif [ $1 -eq 9 ] ; then
    CUDA_SM_LIST='sm_30 sm_32 sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70'
  elif [ $1 -eq 10 ] ; then
    CUDA_SM_LIST='sm_30 sm_32 sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75'
  elif [ $1 -eq 11 ] ; then
    if [ $2 -lt 1 ] ; then
      CUDA_SM_LIST='sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80'
    elif [ $2 -gt 7 ] ; then
      CUDA_SM_LIST='sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86 sm_87 sm_89'
    elif [ $2 -gt 4 ] ; then
      CUDA_SM_LIST='sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86 sm_87'
    else
      CUDA_SM_LIST='sm_35 sm_37 sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86'
    fi
  elif [ $1 -eq 12 ] ; then
    if [ $2 -le 7 ] ; then
      CUDA_SM_LIST='sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86 sm_87 sm_89 sm_90'
    elif [ $2 -eq 8 ] ; then
      CUDA_SM_LIST='sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86 sm_87 sm_89 sm_90 sm_120'
    elif [ $2 -eq 9 ] ; then
      CUDA_SM_LIST='sm_50 sm_52 sm_53 sm_60 sm_61 sm_62 sm_70 sm_72 sm_75 sm_80 sm_86 sm_87 sm_89 sm_90 sm_120 sm_121'
    else
      echo "CUDA 12.$2 has not been tested yet. Set SHADER_MODEL manually."
      exit 1
    fi
  else
    echo "Automatic shader model detection for CUDA $1.$2 is currently unsupported. Set SHADER_MODEL manually."
    exit 1
  fi
  echo "  Supported shader models: $CUDA_SM_LIST"
}

# SetCudaArch <sm>
# Set CUDA_ARCH variable with compute_XX value for given SM
SetCudaArch() {
  smversion=${1#sm_}
  # compute_21 is not a thing
  if [ "$smversion" = '21' ] ; then
    CUDA_ARCH="compute_20"
  else
    CUDA_ARCH="compute_$smversion"
  fi
  #echo "$1 $CUDA_ARCH"
}

# ------------------------------------------------------------------------------
# Check that CUDA_HOME is defined and set up flags for nvcc
SetupCUDA() {
  if [ -z "$CUDA_HOME" ] ; then
    Err "CUDA_HOME not set. Set CUDA_HOME to point to your NVIDIA tools installation."
  fi
  if [ ! -x "$CUDA_HOME/bin/nvcc" ]; then
    Err "nvcc cuda compiler not found in $CUDA_HOME/bin"
  fi
  if [ -z "$NVCC" ]; then NVCC="$CUDA_HOME/bin/nvcc"; fi
  cuda_version=`$NVCC --version | grep 'release' | cut -d' ' -f5 | cut -d',' -f1`
  cuda_major_version=`echo "$cuda_version" | awk 'BEGIN{FS=".";}{printf("%i", $1);}'`
  cuda_minor_version=`echo "$cuda_version" | awk 'BEGIN{FS=".";}{printf("%i", $2);}'`
  echo "  CUDA version $cuda_version detected."
  # A zero version indicates version detection failed.
  if [ $cuda_major_version -lt 1 ] ; then
    Err "CUDA version detection failed."
  fi
  SetSupportedSM $cuda_major_version $cuda_minor_version

  if [ -z "$NVCCFLAGS" -a -z "$SHADER_MODEL" ] ; then
    # Compile for multiple shader models
    WrnMsg "SHADER_MODEL not set. Compiling for multiple architectures."
    WrnMsg "To compile for a specific architecture set SHADER_MODEL"
    WrnMsg "to 'sm_XX', where XX is the shader model version."
    # TODO determine why Amber has arch=compute_60 for 70 and 75
    SM_CONFIG="Configuring for"
    NVCCFLAGS="$DBFLAG"
    # Loop over supported shader models for this CUDA
    for sm in $CUDA_SM_LIST ; do
      SetCudaArch $sm
      SM_CONFIG="$SM_CONFIG $sm"
      NVCCFLAGS="$NVCCFLAGS -gencode arch=$CUDA_ARCH,code=$sm"
    done
  elif [ -z "$NVCCFLAGS" -a ! -z "$SHADER_MODEL" ] ; then
    # Compile for single shader model
    SM_CONFIG="Configuring for $SHADER_MODEL"
    # See if it is supported.
    sm_is_supported=0
    for sm in $CUDA_SM_LIST ; do
      if [ "$sm" = "$SHADER_MODEL" ] ; then
        sm_is_supported=1
        break
      fi
    done
    if [ $sm_is_supported -eq 0 ] ; then
      Err "Shader model $SHADER_MODEL is not supported by CUDA $cuda_version"
    fi
    NVCCFLAGS="$DBFLAG -arch=$SHADER_MODEL"
  else
    # Use specified NVCC flags
    SM_CONFIG="Using NVCCFLAGS: $NVCCFLAGS"
  fi
  if [ ! -z "$picflag" ] ; then
    NVCCFLAGS="--compiler-options $picflag $NVCCFLAGS"
  fi
  LIB_STAT[$LCUDA]='specified'
  LIB_HOME[$LCUDA]=$CUDA_HOME
}

# ------------------------------------------------------------------------------
# Check that HIP_HOME is defined and set up flags for nvcc
SetupHIP() {
  if [ -z "$HIP_HOME" ] ; then
    HIP_HOME="/opt/rocm"
    echo "HIP_HOME not set, '$HIP_HOME' will be used"
  fi
  if [ ! -x "$HIP_HOME/bin/hipcc" ]; then
    Err "Error: hipcc HIP compiler not found in $HIP_HOME/bin"
  fi
  if [ -z "$NVCC" ]; then NVCC="$HIP_HOME/bin/hipcc"; fi
  if [ -z "$NVCCFLAGS" ] ; then
    NVCCFLAGS="-fPIC $NVCCFLAGS"
  fi
  NVCCFLAGS="${LIB_D_ON[$LHIP]} $NVCCFLAGS"
  if [ ! -z "$picflag" ] ; then
    NVCCFLAGS="$picflag $NVCCFLAGS"
  fi
  LIB_STAT[$LHIP]='specified'
  LIB_HOME[$LHIP]=$HIP_HOME
}

# ------------------------------------------------------------------------------
# Basic checks, set up some directives
BasicChecks() {
  # Check install directory
  if [ -z "$CPPTRAJHOME" ] ; then
    # Default is to use current directory.
    CPPTRAJHOME=`pwd`
    CPPTRAJBIN=$CPPTRAJHOME/bin
    CPPTRAJLIB=$CPPTRAJHOME/lib
    CPPTRAJINC=$CPPTRAJHOME/include
    CPPTRAJDAT=$CPPTRAJHOME/dat
    # No need to install data directory
    INSTALL_DAT=''
  elif [ ! -d "$CPPTRAJHOME" ] ; then
    Err "Install directory '$CPPTRAJHOME' does not exist."
  fi
  # Test incompatible options
  if [ "$PLATFORM" = 'windows' ] ; then
    if [ $USE_MPI -ne 0 ] ; then
      Err "MPI not currently supported on Windows."
    fi
    if [ $USE_OPENMP -ne 0 ] ; then
      Err "OpenMP not currently supported on Windows."
    fi
    #echo "WINDOWS support requested. Implies '-static'."
    #USE_STATIC=1
  fi
  # Decide what to do about parallel netcdf
  if [ "${LIB_STAT[$LPARANC]}" != 'off' -a $USE_MPI -eq 0 ] ; then
    # Check for mpiicpc before assuming mpicxx
    if [ ! -z "`which mpiicpc`" ] ; then
      WrnMsg "Parallel NetCDF enabled but MPI not specified. Assuming '-intelmpi'."
      USE_MPI=2
    else
      WrnMsg "Parallel NetCDF enabled but MPI not specified. Assuming '-mpi'."
      USE_MPI=1
    fi
  elif [ $USE_MPI -ne 0 -a "${LIB_STAT[$LPARANC]}" = 'off' -a "${LIB_DISABLED[$LPARANC]}" = 'false' ] ; then
    # If automatically building libs, enabled parallel netcdf for MPI.
    # Otherwise make it optional by specifying 'optional'
    if [ $BUILD_LIBS -eq 1 ] ; then
      LIB_STAT[$LPARANC]='enabled'
    else
      # The 'optional' option only works if checks are enabled.
      if [ "$PERFORM_CHECKS" = 'yes' ] ; then
        LIB_STAT[$LPARANC]='optional'
      fi
    fi
  fi
  # If we are using the bundled ARPACK then we will need C++/Fortran linking.
  if [ "${LIB_STAT[$LARPACK]}" = 'bundled' ] ; then
    REQUIRES_FLINK=1
  fi
  # TODO if we skipped checks we may need the FLINK flag enabled
  # Binary suffix
  if [ $USE_MPI -ne 0    ] ; then SFX=$SFX".MPI"  ; fi
  if [ $USE_OPENMP -ne 0 ] ; then SFX=$SFX".OMP"  ; fi
  if [ $USE_CUDA -ne 0   ] ; then SFX=$SFX".cuda" ; fi
  if [ $USE_HIP  -ne 0   ] ; then SFX=$SFX".hip"  ; fi
}

#-------------------------------------------------------------------------------
# Platform-specific tests
PlatformTests() {
  # C++11 support
  if [ "$C11_SUPPORT" = 'yes' ] ; then
    # First try to test a basic C++11 construct
    cat > testp.cpp <<EOF
#include <initializer_list>
int main() { constexpr int a = 5; auto b = a; for (auto i : {1, 2, 3}) { b += i; } return 0; }
EOF
    TestProgram silent "  Testing basic C++11 support" "$CXX" "$CXXFLAGS $C11FLAG" testp.cpp
    if [ $? -eq 1 ] ; then
      echo "Not present"
      C11_SUPPORT='no'
    else
      C11_SUPPORT='yes'
      # Next, test GNU backend for at least 4.8.1 support.
      # Clang requires >= 3.3.
      cat > testp.cpp <<EOF
#include <cstdio>
int main() {
#ifdef __clang_major__
// Test for Clang >= 3.3
  printf("Clang %i.%i.%i\n", __clang_major__, __clang_minor__, __clang_patchlevel__);
  int badClang = 1;
#if __clang_major__ > 3
  badClang = 0;
#elif (__clang_major__ == 3 && __clang_minor__ > 2)
  badClang = 0;
#endif
  if (badClang == 1)
    printf("Clang < 3.3 detected.\n");
  else
    printf("Clang >= 3.3 detected.\n");
  return badClang;
#else
// Test for GCC >= 4.8.1
  printf("GCC %i.%i.%i\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
  int badGcc = 1;
#if __GNUC__ > 4
  badGcc = 0;
#elif (__GNUC__ == 4 && __GNUC_MINOR__ > 8)
  badGcc = 0;
#elif (__GNUC__ == 4 && __GNUC_MINOR__ == 8 && __GNUC_PATCHLEVEL__ > 0)
  badGcc = 0;
#endif
  if (badGcc == 1)
    printf("GCC < 4.8.1 detected.\n");
  else
    printf("GCC >= 4.8.1 detected.\n");
  return badGcc;
#endif /* GCC/Clang */
}
EOF
      echo -n "  Testing system headers for C++11 support: "
      $CXX $CXXFLAGS $C11FLAG -o testp testp.cpp > $COMPOUT 2> $COMPERR
      if [ $? -ne 0 ] ; then
        C11_SUPPORT='no'
      else
        ./testp > prog.out
        if [ $? -ne 0 ] ; then
          C11_SUPPORT='no'
        fi
        rm -f testp prog.out
      fi
      rm -f $COMPOUT $COMPERR
      if [ "$C11_SUPPORT" = 'no' ] ; then
        echo "Not supported"
      else
        echo "OK"
        CXXFLAGS="$CXXFLAGS $C11FLAG"
      fi
    fi
  fi
  # Some compilers (like older Intel) have a problem with the order of
  # stdio vs mpi
  if [ $USE_MPI -ne 0 ] ; then
    cat > testp.cpp <<EOF
#include <cstdio>
#include <mpi.h>
int main() { printf("Testing a C++ MPI program.\n"); return 0; }
EOF
    TestProgram quiet "  Testing STDIO/MPI ordering" "$CXX" "$CXXFLAGS" testp.cpp
    if [ $? -eq 1 ] ; then
      # Try to fix it with -DMPICH_IGNORE_CXX_SEEK
      TestProgram "  Testing fix for STDIO/MPI ordering" "$CXX" "$CXXFLAGS -DMPICH_IGNORE_CXX_SEEK" testp.cpp
      # That worked. Add to CXXFLAGS
      CXXFLAGS="$CXXFLAGS -DMPICH_IGNORE_CXX_SEEK"
    fi
  fi
  if [ "$COMPILERS" = 'clang' ] ; then
      # On OSX with clang, some libraries may be built with libstdc++ and will
      # fail to link without this flag.
      cat > testp.cpp <<EOF
#include <cstdio>
#include <string>
int main() { std::string temp("Testing"); printf("%s\n", temp.c_str()); return 0; }
EOF
      TestProgram quiet "Without stdlib flag" "$CXX" "$CXXFLAGS" testp.cpp
      if [ $? -eq 1 ] ; then
        # Test with stdlib flag
        TestProgram quiet "With stdlib flag" "$CXX" "$CXXFLAGS" testp.cpp "-stdlib=libstdc++"
        if [ $? -eq 1 ] ; then
          Err "Could not link libstdc++ properly with clang++"
        fi
        LDFLAGS="$LDFLAGS -stdlib=libstdc++"
      fi
      # Test that clang can link between C++ and fortran
      if [ $REQUIRES_FLINK -eq 1 ] ; then
        echo -n "  Testing clang C++/Fortran linking: "
        cat > testc.cpp <<EOF
#include <cstdio>
extern "C" { void mytest_(int&); } int main() { int ival=14; printf("Testing"); mytest_(ival); }
EOF
        $CXX $CXXFLAGS -c -o testc.o testc.cpp > $COMPOUT 2> $COMPERR
        if [ $? -ne 0 ] ; then
          cat $COMPERR >&2
          exit 1
        fi
        cat > testf.f <<EOF
subroutine mytest(ival)
  implicit none
  integer, intent(in) :: ival
  write(6,'(a,i6)') ' cross-link ', ival
end subroutine mytest
EOF
        $FC $FFLAGS -c -o testf.o testf.f > $COMPOUT 2> $COMPERR
        if [ $? -ne 0 ] ; then
          cat $COMPERR >&2
          exit 1
        fi
        TestProgram quiet "clang++/gfortran link" "$CXX" " " "testc.o testf.o" "$FLINK"
        if [ $? -ne 0 ] ; then
          # Probably missing lgfortran Search for it
          fortlib_dir=''
          for fl_dir in `$FC -print-search-dirs | grep "libraries:" | awk 'BEGIN{FS="[=:]";}{
            for (col=2; col <= NF; col++)
              print $col;
          }'` ; do
            TestProgram quiet "test" "$CXX" " " "testc.o testf.o" "-L$fl_dir $FLINK"
            if [ $? -eq 0 ] ; then
              fortlib_dir=$fl_dir
              break
            fi
          done
          if [ -z "$fortlib_dir" ] ; then
            Err "Cannot link C++ and Fortran with clang."
          fi
          # Make sure system lib dir is searched before libgfortran dir.
          # See https://github.com/Amber-MD/cpptraj/pull/473
          FLINK="-L/usr/lib -L$fortlib_dir $FLINK"
        fi
        echo "OK"
      fi
  fi # End if clang
  # ----- Mac OSX --------------------------------
  if [ "$PLATFORM" = 'Darwin' ] ; then
    SHARED_SUFFIX='.dylib'

  # ----- Windows/Cygwin -------------------------
  elif [ "$PLATFORM" = 'windows' ] ; then
    SHARED_SUFFIX='.dll.a'
    EXE='.exe'
  # ----- Cygwin ---------------------------------
  elif [ ! -z "`echo $PLATFORM | grep -i cygwin`" ] ; then
    SHARED_SUFFIX='.dll'
  # ----- Linux (default) ------------------------
  else
    SHARED_SUFFIX='.so'
  fi
}

#-------------------------------------------------------------------------------
# Add cmake prefix path
AddCmakePrefixPath() {
  # Search for existing
  for ((idx1=0; idx1 < $icpp; idx1++)) ; do
    if [ "$1" = "${cmake_prefix_paths[$idx1]}" ] ; then
      #echo DEBUG duplicate path $1
      return 0
    fi
  done
  #echo DEBUG add cmake prefix path $icpp $1
  cmake_prefix_paths[$icpp]=$1
  ((icpp++))
}

# Use cmake to configure build.
SetupCmake() {
  CMAKE=`which cmake`
  if [ -z "$CMAKE" ] ; then
    Err "'cmake' binary not found. Cannot configure with cmake."
  fi
  # Not recommended to run in same directory as configure
  if [ "$WORKDIR" = '.' ] ; then
    ErrMsg "Error: 'cmake' configure should be done in a separate directory."
    ErrMsg "       e.g. $ cd \$CPPTRAJHOME"
    ErrMsg "            $ mkdir build"
    ErrMsg "            $ cd build"
    ErrMsg "            $ ../configure -cmake <options>"
    exit 1
  fi
  # Ensure cmake build system exists
  if [ ! -f "$WORKDIR/cmake-cpptraj/BuildSystemInit.cmake" ] ; then
    ErrMsg "Error: cmake build system is not present."
    exit 1
  fi
  # Set up cmake options
  cmake_options=''
  # Figure out compilers
  if [ "$COMPILERS" = 'gnu' ] ; then
    cmake_options='-DCOMPILER=GNU'
  elif [ "$COMPILERS" = 'intel' ] ; then
    cmake_options='-DCOMPILER=INTEL'
  elif [ "$COMPILERS" = 'pgi' ] ; then
    cmake_options='-DCOMPILER=PGI'
  elif [ "$COMPILERS" = 'clang' ] ; then
    cmake_options='-DCOMPILER=CLANG'
  elif [ "$COMPILERS" = 'cray' ] ; then
    cmake_options='-DCOMPILER=CRAY'
  fi
  # Build options
  if [ "$USE_MPI" -eq 0 ] ; then
    cmake_options="$cmake_options -DMPI=FALSE"
  else
    cmake_options="$cmake_options -DMPI=TRUE"
  fi
  if [ "$USE_OPENMP" -eq 0 ] ; then
    cmake_options="$cmake_options -DOPENMP=FALSE"
  else
    cmake_options="$cmake_options -DOPENMP=TRUE"
  fi
  if [ "$USE_CUDA" -eq 0 ] ; then
    cmake_options="$cmake_options -DCUDA=FALSE"
  else
    cmake_options="$cmake_options -DCUDA=TRUE"
  fi
  #if [ "${LIB_STAT[$LFFTW3]}" = 'off' ] ; then
  #  cmake_options="$cmake_options -DUSE_FFT=FALSE"
  #fi
  if [ $USE_STATIC -eq 1 ] ; then
    cmake_options="$cmake_options -DSTATIC=TRUE"
  fi
  if [ ! -z "$CPPTRAJHOME" ] ; then
    cmake_options="$cmake_options -DCMAKE_INSTALL_PREFIX=$CPPTRAJHOME"
  else
    cmake_options="$cmake_options -DCMAKE_INSTALL_PREFIX=$WORKDIR"
  fi
  if [ $USE_OPT -eq 0 ] ; then
    cmake_options="$cmake_options -DOPTIMIZE=FALSE"
  else
    cmake_options="$cmake_options -DOPTIMIZE=TRUE"
  fi
  if [ $USE_DEBUG -eq 0 ] ; then
    cmake_options="$cmake_options -DCMAKE_BUILD_TYPE=Release"
  else
    cmake_options="$cmake_options -DCMAKE_BUILD_TYPE=Debug"
  fi
  if [ $COMPILE_VERBOSE -eq 1 ] ; then
    cmake_options="$cmake_options -DCMAKE_VERBOSE_MAKEFILE=TRUE"
  fi
  # Libraries
  icpp=0
  for ((idx=0; idx < $NLIB; idx++)) ; do
    if [ "${LIB_STAT[$idx]}" = 'specified' ] ; then
      #echo Lib $idx # DEBUG
      AddCmakePrefixPath "${LIB_HOME[$idx]}"
    fi
  done
  #if [ "${LIB_STAT[$LNETCDF]}" = 'specified' ] ; then
  #  AddCmakePrefixPath "${LIB_HOME[$LNETCDF]}"
  #fi
  #if [ "${LIB_STAT[$LZIP]}" = 'specified' ] ; then
  #  AddCmakePrefixPath "${LIB_HOME[$LZIP]}"
  #fi
  #if [ "${LIB_STAT[$LBZIP]}" = 'specified' ] ; then
  #  AddCmakePrefixPath "${LIB_HOME[$LBZIP]}"
  #fi

  if [ $icpp -gt 0 ] ; then
    cmppstring=""
    for ((idx=0; idx < $icpp; idx++)) ; do
      if [ ! -z "$cmppstring" ] ; then
        cmppstring="$cmppstring;${cmake_prefix_paths[$idx]}"
      else
        cmppstring="${cmake_prefix_paths[$idx]}"
      fi
    done
    cmake_options="$cmake_options -DCMAKE_PREFIX_PATH=$cmppstring"
  fi  
  echo "  Cmake options: $WORKDIR $cmake_options"
  # Run cmake
  $CMAKE $WORKDIR $cmake_options
  exit $?
}

# ==============================================================================
# MAIN SCRIPT

# Check requirements
if [ -z "`which awk`" ] ; then
  Err "CPPTRAJ configure requires 'awk'."
fi
if [ -z "`which grep`" ] ; then
  Err "CPPTRAJ configure requires 'grep'."
fi

# Check for the 'install/ binary
INSTALL=`which install`
if [ -z "$INSTALL" ] ; then
  Err "CPPTRAJ configure requires 'install'."
fi

#echo "Path to configure: $WORKDIR"
#echo "Current dir      : $CURRENTDIR"

CONFIGURECMD="./configure $*"

# Process user options.
KEY=''
VALUE=''
while [ ! -z "$1" ] ; do
  VALUE=''
  # Check for '='
  #POS=`expr index "$1" =` # NOT PORTABLE
  POS=`echo $1 | awk 'match($0,"="){print RSTART}'`
  if [ -z "$POS" ] ; then POS=0 ; fi
  if [ $POS -eq 1 ] ; then
    Err "'=' cannot be the first character in an argument ($1)"
  elif [ $POS -gt 1 ] ; then
    # Separate into KEY and VALUE
    ((PM1 = $POS - 1))
    KEY=${1:0:$PM1}
    VALUE=${1:$POS}
    if [ -z "$VALUE" ] ; then
      Err "'$1': Expected <var>=<value>, missing <value>."
    fi
    eval VALUE=$VALUE 2> temp.err
    rm temp.err
  else
    KEY=$1
  fi
  #echo "KEY='$KEY'  VALUE='$VALUE'" # DEBUG
  # Process KEY
  case "$KEY" in
    '--help' | '-h' ) UsageSimple ; exit 0 ;;
    '--full-help'   ) UsageFull   ; exit 0 ;;
    # Compiler Options
    'gnu'        ) COMPILERS=$KEY ;;
    'clang'      ) COMPILERS=$KEY ;;
    'intel'      ) COMPILERS=$KEY ;;
    'oneapi'     ) COMPILERS=$KEY ;;
    'pgi'        ) COMPILERS=$KEY ;;
    'cray'       ) COMPILERS=$KEY ;;
    'CXX'        ) CXX="$VALUE" ;;
    'CC'         ) CC="$VALUE" ;;
    'FC'         ) FC="$VALUE" ;;
    'MPICXX'     ) MPICXX="$VALUE" ;;
    'MPICC'      ) MPICC="$VALUE" ;;
    'MPIF90'     ) MPIF90="$VALUE" ;;
    'CXXFLAGS'   ) CXXFLAGS="$VALUE" ;;
    'CFLAGS'     ) CFLAGS="$VALUE" ;;
    'FFLAGS'     ) FFLAGS="$VALUE" ;;
    'F77FLAGS'   ) F77FLAGS="$VALUE" ;;
    'LDFLAGS'    ) LDFLAGS="$VALUE" ;;
    'DBGFLAGS'   ) DBGFLAGS="$VALUE" ;;
    'NVCC'       ) NVCC="$VALUE" ;;
    'NVCCFLAGS'  ) NVCCFLAGS="$VALUE" ;;
    'CUDA_HOME'  ) CUDA_HOME="$VALUE" ;;
    'HIP_HOME'   ) HIP_HOME="$VALUE" ;;
    'SHADER_MODEL') SHADER_MODEL="$VALUE" ;;
    # Build options
    '-cmake'         ) USE_CMAKE=1 ;;
    '-mpi'           ) USE_MPI=1 ;;
    '-intelmpi'      ) USE_MPI=2 ;;
    '-openmp'        ) USE_OPENMP=1 ;;
    '-cuda'          ) USE_CUDA=1 ;;
    '-hip'           ) USE_HIP=1 ;;
    '-cray'          ) PLATFORM='cray' ;;
    '-mkl'           ) BLAS_TYPE='mkl' ;;
    '-nomklfftw'     ) MKL_FFTW='no' ;;
    '-libsci'        ) BLAS_TYPE='libsci' ;;
    '-openblas'      ) BLAS_TYPE='openblas' ;;
    '-macAccelerate' ) BLAS_TYPE='macAccelerate' ;;
    '-debug'         ) USE_DEBUG=1 ;;
    '-d'             ) USE_OPT=0 ; USE_DEBUG=1 ;;
    '-noopt'         ) USE_OPT=0 ;;
    '-tune'          ) USE_OPT=2 ;;
    '-noc++11'       ) C11_SUPPORT='no' ;;
    '-windows'       ) PLATFORM='windows' ;;
    '-pubfft'        ) LIB_STAT[$LFFTW3]='off' ;;
    # Cpptraj options
    '-nolfs'           ) LFS='' ;;
    '-single-ensemble' ) USE_SINGLEENSEMBLE=1 ;;
    '-debugon'         ) USE_CPPTRAJDEBUG=1 ;;
    '-leappi'          ) USE_LEAP_PI=1 ;;
    # Code profiling
    '-profile'  ) USE_PROFILE=1 ;;
    '-gprofile' ) USE_PROFILE=2 ;;
    '-vtune'    ) USE_PROFILE=3 ;;
    # Linking options
    '-static'           ) USE_STATIC=1 ;;
    '-libstatic'        ) USE_STATIC=2 ;;
    '-shared'           )
      USE_SHARED=1
#      LIB_STAT[$LSANDER]='off'
      ;;
    '-amberlib'         )
      if [ -z "$AMBERHOME" ] ; then
        Err "'-amberlib' requires that AMBERHOME be set."
      fi
      USE_AMBERLIB=1
      ;;
    '-nomathlib'        ) BLAS_TYPE='none' ;;
    '--requires-flink'  ) REQUIRES_FLINK=1 ;;
    '--requires-pthread') REQUIRES_PTHREAD=1 ;;
    '--buildlibs'       ) BUILD_LIBS=1 ;;
    '--nobuildlibs'     ) BUILD_LIBS=0 ; BUILDTESTOPT='' ;;
    '--libdir'          ) SPECIFIED_LIB_DIR=$VALUE ;;
    # Install options
    '--compile-verbose' ) COMPILE_VERBOSE=1 ;;
    '-noclean'          ) CLEAN='no' ;;
    '--skip-checks'     ) PERFORM_CHECKS='no' ;;
    '--prefix'          )
      CPPTRAJHOME=$VALUE
      CPPTRAJBIN=$VALUE/bin
      CPPTRAJLIB=$VALUE/lib
      CPPTRAJINC=$VALUE/include
      CPPTRAJDAT=$VALUE/dat
      ;;
    '--build-mpi'        )
      BUILD_MPI=$VALUE
      ;;
    # Hidden debug options
    '--debug-parallel'  ) DIRECTIVES="$DIRECTIVES -DPARALLEL_DEBUG_VERBOSE" ;;
    * ) # Check for library keys
      CheckLibraryKeys "$KEY" "$VALUE"
      if [ $? -eq 1 ] ; then
        Err "Unrecognized Option '$1'. Use '-h' or '--help' for help."
      fi
      ;;
  esac
  shift
done

# If CUDA is no longer off, turn it on.
if [ "${LIB_STAT[$LCUDA]}" != 'off' -a $USE_CUDA -eq 0 ] ; then
  echo '  Enabling CUDA.'
  USE_CUDA=1
fi

# Determine platform if not already specified
if [ -z "$PLATFORM" ] ; then
  PLATFORM=`uname -s | awk '{print $1}'`
fi

# Determine architecture bits if not already specified
if [ -z "$NBITS" ] ; then
  architecture=`uname -m`
  if [ -z "$architecture" ] ; then
    WrnMsg "Could not determine 32 vs 64-bit OS - assuming 64-bit."
    NBITS=64
  elif [ ! -z "`echo $architecture | grep 64`" ] ; then
    # Assume if the machine from uname has a 64 it is 64 bit.
    NBITS=64
  else
    NBITS=32
  fi
fi

# Should we use cmake instead?
if [ $USE_CMAKE -eq 1 ] ; then
  SetupCmake
fi

# Currently need to execute configure in source directory
if [ "$WORKDIR" != '.' ] ; then
  Err "CPPTRAJ configure must be executed from the source directory."
fi
#CPPTRAJSRC=$CURRENTDIR

# Basic checks and directives
BasicChecks

# Create directories if necessary 
if [ ! -e "$CPPTRAJBIN" ] ; then
  mkdir "$CPPTRAJBIN"
fi
if [ ! -e "$CPPTRAJLIB" ] ; then
  mkdir "$CPPTRAJLIB"
fi
if [ ! -e "$CPPTRAJDAT" ] ; then
  mkdir "$CPPTRAJDAT"
fi

# Set up compilers and compiler options
SetupCompilers

if [ "$USE_CUDA" -eq 1 -a "$USE_HIP" -eq 1 ] ; then
  Err "-cuda and -hip are mutually exclusive."
fi

# Set up CUDA if needed
if [ "$USE_CUDA" -eq 1 ] ; then
  SetupCUDA
fi

# Set up HIP if needed
if [ "$USE_HIP" -eq 1 ] ; then
  SetupHIP
fi

# Set up profiling if specified
SetupProfiling

# Basic Compiler tests
if [ "$PERFORM_CHECKS" = 'yes' ] ; then
  TestCompilers
fi

# Platform-specific tests
PlatformTests

# Set up external libraries
SetupLibraries

# Test external libraries
TestLibraries

# Set final compile flags
SetupFinalFlags

# ----- Summary ----------------------------------
echo ""
echo "Configuration summary:"
echo -n "  Build type:"
if [ $USE_MPI -eq 0 -a $USE_OPENMP -eq 0 -a $USE_CUDA -eq 0 -a $USE_HIP -eq 0 ] ; then
  echo " Serial"
elif [ $USE_MPI -eq 0 -a $USE_OPENMP -eq 0 -a $USE_CUDA -eq 0 -a $USE_HIP -ne 0 ] ; then
  echo " HIP"
elif [ $USE_MPI -eq 0 -a $USE_OPENMP -eq 0 -a $USE_CUDA -ne 0 -a $USE_HIP -eq 0 ] ; then
  echo " CUDA"
else
  if [ $USE_MPI -ne 0 -a $USE_OPENMP -ne 0 ] ; then
    echo -n " Hybrid MPI/OpenMP"
  elif [ $USE_MPI -ne 0 ] ; then
    echo -n " MPI"
  elif [ $USE_OPENMP -ne 0 ] ; then
    echo -n " OpenMP"
  fi
  if [ $USE_CUDA -ne 0 ] ; then
    echo " + CUDA"
  elif [ $USE_HIP -ne 0 ] ; then
    echo " + HIP"
  else
    echo ""
  fi
fi
if [ ! -z "$SM_CONFIG" ] ; then
  echo "  $SM_CONFIG"
fi
# DEBUG
#for ((i=0; i < $NLIB; i++)) ; do
#  echo " Library: ${LIB_CKEY[$i]} (${LIB_STAT[$i]})"
#done
echo -n "  Options:"
for ((i=0; i < $NLIB; i++)) ; do
  if [ "${LIB_STAT[$i]}" != 'off' ] ; then
    echo -n " ${LIB_CKEY[$i]}"
  fi
done
echo ""
if [ $USE_SINGLEENSEMBLE -ne 0 ] ; then
  echo "  Support for single-ensemble trajectories enabled."
fi
echo "  Target platform: $PLATFORM, $NBITS-bit."
echo "  $COMPILERS compilers in use."
if [ "$MKL_FFTW" = 'yes' ] ; then
  echo "  Using FFTW from MKL."
fi
if [ "$C11_SUPPORT" = 'yes' ] ; then
  echo "  C++11 support enabled."
  if [ "${LIB_STAT[$LFFTW3]}" = 'off' ] ; then
    echo "  PME support disabled (requires FFTW3)."
  else
    echo "  PME support enabled."
  fi
else
  echo "  C++11 support disabled."
  echo "  PME support disabled (requires C++11 and FFTW3)."
fi
if [ $USE_OPT -eq 1 ] ; then
  echo "  Compiler optimizations are on."
elif [ $USE_OPT -eq 2 ] ; then
  echo "  Compiler optimizations and native host tuning are on."
  if [ ! -z "$TUNEFLAGS" ] ; then
    echo "  Custom host tuning flags: $TUNEFLAGS"
  fi
else
  echo "  Compiler optimizations are off."
fi
if [ $USE_DEBUG -ne 0 ] ; then
  echo "  Compiler debug symbols are on."
fi
if [ $USE_PROFILE -ne 0 ] ; then
  echo "  Code profiling is on."
fi
if [ "$BLAS_TYPE" != 'other' -a "$BLAS_TYPE" != 'none' ] ; then
  echo "  BLAS/LAPACK from: $BLAS_TYPE"
fi
if [ -z "$LFS" ] ; then
  echo "  Large file support is off."
fi
if [ $USE_STATIC -eq 1 ] ; then
  echo "  Using static linking."
elif [ $USE_STATIC -eq 2 ] ; then
  echo "  Specified libraries will be linked statically if possible."
fi
if [ $USE_LEAP_PI -eq 1 ] ; then
  echo "  Using LEaP's value of PI for converting radians/degrees."
fi
#echo DIRECTIVES $DIRECTIVES
#echo CFLAGS $CFLAGS
#echo CXXFLAGS $CXXFLAGS
#echo FFLAGS $FFLAGS
#echo LDFLAGS $LDFLAGS
#echo CPPTRAJ_LIB $CPPTRAJ_LIB
#echo CPPTRAJONLY_LIB $CPPTRAJONLY_LIB
#echo CPPTRAJ_INC $CPPTRAJ_INC
#echo REQUIRES_FLINK $REQUIRES_FLINK FLINK $FLINK
echo ""

if [ $USE_MPI -ne 0 -a "${LIB_STAT[$LPARANC]}" = 'off' ] ; then
  echo "************************************************************************"
  echo "* Warning: No parallel NetCDF library specified.                       *"
  echo "* Warning: NetCDF parallel trajectory output requires parallel NetCDF. *"
  echo "************************************************************************"
fi

# ----- Determine which targets to build ---------
CPPTRAJ_TARGET=""
LIBCPPTRAJ_TARGET=""
NPROC_TARGET=""
INSTALL_TARGETS="$INSTALL_DAT"
# Always build cpptraj
CPPTRAJ_TARGET=cpptraj$SFX$EXE
INSTALL_TARGETS=$INSTALL_TARGETS" install_cpptraj"
# Can we build libcpptraj? TODO serial/OpenMP only?
if [ $USE_SHARED -eq 1 ] ; then
  LIBCPPTRAJ_TARGET='$(CPPTRAJLIB)/libcpptraj$(SHARED_SUFFIX)'
  INSTALL_TARGETS=$INSTALL_TARGETS" libcpptraj"
else
  LIBCPPTRAJ_TARGET='nolibcpptraj'
fi
# CUDA
if [ $USE_CUDA -ne 0 -o $USE_HIP -ne 0 ] ; then
  CUDA_TARGET='cuda_kernels/libcpptraj_cuda.a'
fi
# Readline
if [ "${LIB_STAT[$LREADLINE]}" = 'bundled' ] ; then
  READLINE_TARGET=${LIB_FLAG[$LREADLINE]}
else
  READLINE_TARGET='noreadline'
fi
# Xdrfile
if [ "${LIB_STAT[$LXDRFILE]}" = 'bundled' ] ; then
  XDRFILE_TARGET=${LIB_FLAG[$LXDRFILE]}
else
  XDRFILE_TARGET='noxdrfile'
fi
# TNG
if [ "${LIB_STAT[$LTNGFILE]}" = 'bundled' ] ; then
  TNGFILE_TARGET=${LIB_FLAG[$LTNGFILE]}
else
  TNGFILE_TARGET='notngfile'
fi
# Arpack
if [ "${LIB_STAT[$LARPACK]}" = 'bundled' ] ; then
  ARPACK_TARGET=${LIB_FLAG[$LARPACK]}
else
  ARPACK_TARGET='noarpack'
fi
# FFT
if [ "${LIB_STAT[$LFFTW3]}" = 'off' ] ; then
  FFT_TARGET='pub_fft.o'
else
  FFT_TARGET=''
fi

# ----- Write config.h ---------------------------
cat > config.h <<EOF
# config.h for cpptraj
# configured using: $CONFIGURECMD
EOF
if [ $USE_CUDA -eq 1 -a ! -z "$SHADER_MODEL" ] ; then
  echo "# SHADER_MODEL=$SHADER_MODEL" >> config.h
fi
cat >> config.h <<EOF

CPPTRAJHOME="$CPPTRAJHOME"
CPPTRAJBIN="$CPPTRAJBIN"
CPPTRAJLIB="$CPPTRAJLIB"
CPPTRAJINC="$CPPTRAJINC"
CPPTRAJDAT="$CPPTRAJDAT"

INSTALL_TARGETS=$INSTALL_TARGETS

INSTALL=$INSTALL
INSTALL_PROGRAM=$INSTALL
INSTALL_DATA=$INSTALL -m 644

EOF
if [ ! -z "$DBGFLAGS" ] ; then
  echo "DBGFLAGS=$DBGFLAGS" >> config.h
fi
cat >> config.h <<EOF
SHARED_SUFFIX=$SHARED_SUFFIX
DIRECTIVES=$DIRECTIVES
LFS=$LFS
CPPTRAJ_INC=$CPPTRAJ_INC

LIBCPPTRAJ_TARGET=$LIBCPPTRAJ_TARGET

CUDA_TARGET=$CUDA_TARGET

READLINE_TARGET=$READLINE_TARGET
READLINE_LIB=${LIB_FLAG[$LREADLINE]}

XDRFILE_TARGET=$XDRFILE_TARGET

TNGFILE_TARGET=$TNGFILE_TARGET

ARPACK_TARGET=$ARPACK_TARGET

FFT_TARGET=$FFT_TARGET

CPPTRAJ_LIB=$CPPTRAJ_LIB
CPPTRAJONLY_LIB=$CPPTRAJONLY_LIB
LDFLAGS=$LDFLAGS
SFX=$SFX
EXE=$EXE

EOF
# Add '@' symbol to Makefile rules for non-verbose compile
if [ $COMPILE_VERBOSE -eq 0 ] ; then
  echo "VB=@" >> config.h
else
  echo "VB=" >> config.h
fi
# Add compilers and flags
cat >> config.h <<EOF

CXX=$CXX
CXXFLAGS=$CXXFLAGS \$(DBGFLAGS)
CC=$CC
CFLAGS=$CFLAGS \$(DBGFLAGS)
FC=$FC
F77FLAGS=$F77FLAGS \$(DBGFLAGS)
FFLAGS=$FFLAGS \$(DBGFLAGS)
NVCC=$NVCC
NVCCFLAGS=$NVCCFLAGS

EOF

# Zlib needed by tng
if [ "${LIB_STAT[$LZIP]}" != 'off' ] ; then
  echo "ZLIB_FLAG=${LIB_FLAG[$LZIP]}" >> config.h
  echo "ZLIB_INCL=${LIB_INCL[$LZIP]}" >> config.h
fi

# ----- Create a resource file. ------------------
# If PERFORM_CHECKS is 'no' assume we are in AmberTools, no resource file needed.
RFILE=''
if [ "$PERFORM_CHECKS" = 'yes' ] ; then
  if [ -z "`echo $SHELL | grep csh`" ] ; then
    # We have a sane shell
    RFILE=$CPPTRAJHOME/cpptraj.sh
    cat > $RFILE <<EOF
export CPPTRAJHOME="$CPPTRAJHOME"
export PATH=$CPPTRAJBIN:\${PATH}
EOF
    if [ "$PLATFORM" != "Darwin" ] ; then
      echo "export LD_LIBRARY_PATH=$CPPTRAJLIB:\${LD_LIBRARY_PATH}" >> $RFILE
    fi
  else
    # C-shell - blech
    RFILE=$CPPTRAJHOME/cpptraj.csh
    cat > $RFILE <<EOF
setenv CPPTRAJHOME "$CPPTRAJHOME"
setenv PATH "$CPPTRAJBIN:\${PATH}"
EOF
    if [ "$PLATFORM" != "Darwin" ] ; then
      echo "setenv LD_LIBRARY_PATH \"$CPPTRAJLIB:\${LD_LIBRARY_PATH}\"" >> $RFILE
    fi
  fi
fi

# ----- Clean the source directory if necessary --
if [ "$CLEAN" = 'yes' ] ; then
  echo 'Cleaning source directory.'
  cd src && make clean > make.log 2>&1
  rm make.log
fi

if [ ! -z "$RFILE" ] ; then
  echo ""
  echo "--------------------------------------------------------------------------------"
  echo "An environment resource file for CPPTRAJ has been created:"
  echo "  $RFILE"
  echo "You may 'source' this file to set up your environment for CPPTRAJ."
  echo "--------------------------------------------------------------------------------"
  echo ""
  echo "CPPTRAJ configuration complete."
  echo ""
fi
exit 0