make_cp2k.sh

#!/usr/bin/env bash

# Purpose: Build CP2K using Spack and CMake locally within the folder CP2K_ROOT
#          which defaults to the current working directory. This should be a
#          "cp2k/" folder containing the CP2K source tree which can be download with
#
#          > git clone https://github.com/cp2k/cp2k.git cp2k
#
#          and after
#
#          > cd cp2k
#
#          this script can be run in subshell using the default options with
#
#          > ./make_cp2k.sh
#
#          The flags -h or --help print the available options.
#
#          The first run will take longer as it will build all CP2K dependencies
#          with Spack. The Spack installation is kept fully local in the subfolder
#          cp2k/spack which corresponds to the tools/toolchain/install folder
#          created by the CP2K toolchain.
#
#          Subsequent runs of the script will use the software stack from that
#          cp2k/spack/ folder.
#
#          A rebuild of all CP2K dependencies can be enforced simply by removing
#          or renaming the folder cp2k/spack. The latter allows for keeping different
#          software stacks (see also -bd and -bd_only flags).
#
#          It is recommended to store already compiled packages in a cache (default).
#          This will accelerate the (re)build of the CP2K dependencies with Spack
#          significantly (see -uc flag).
#
#          After the CP2K dependencies are built with Spack, CP2K itself is built
#          and installed using CMake in the subfolders cp2k/build and cp2k/install,
#          respectively.
#
#          Subsequent runs of the script will use the CMake configuration in the
#          subfolder cp2k/build. A rebuild of CP2K from scratch can be enforced
#          by removing or renaming that subfolder.
#
#          A CP2K regression run can be launched automatically by adding the flag
#          -t "" (or --test ""). This flag expects a string with the TESTOPTS, e.g.
#
#          > ./make_cp2k.sh -t "--maxtasks 8 --restrictdir QS/regtest-gpw-1"
#
#          Alternatively, the script cp2k/install/bin/run_tests can be launched
#          after a successful CP2K build. Usage examples are printed at the end.

# Authors: Matthias Krack (MK)

# Version: 2.4

# Facilitate the deugging of this script
set -uo pipefail

# Retrieve script name
SCRIPT_NAME="$(basename "${BASH_SOURCE[0]}")"

# Check if the script is sourced or run in a subshell
if [[ "${BASH_SOURCE[0]}" != "${0}" ]]; then
  echo "${SCRIPT_NAME}: Running script in sourcing mode"
  echo "${SCRIPT_NAME}: All changes from this script will become effective within the current shell"
  EXIT_CMD="return"
else
  echo "${SCRIPT_NAME}: Running script in subshell mode"
  echo "${SCRIPT_NAME}: Changes from this script in the shell environment are lost after completion"
  EXIT_CMD="exit"
fi

# Check platform
if [[ "$(uname -s)" == "Darwin" ]]; then
  echo "ERROR: A build for Apple macOS (Darwin, Homebrew) is not supported yet,"
  echo "       but CP2K can be built within a container using podman."
  echo "       Check the Dockerfiles in the folder cp2k/tools/docker like"
  echo "       Dockerfile.test_spack_openmpi-psmp and the usage description in their header"
  ${EXIT_CMD} 1
fi

# Help finding ldconfig
if ! command -v ldconfig &> /dev/null; then
  PATH="${PATH}:/sbin"
fi

# Check if all mandatory packages are installed in the environment
for package in awk bzip2 find g++ gcc gfortran git gzip ldconfig make patch python3 tar wget xz; do
  if ! command -v "${package}" &> /dev/null; then
    echo "ERROR: The package \"${package}\" is mandatory to build CP2K with Spack/CMake"
    echo "       Install the missing package and re-run the script"
    ${EXIT_CMD} 1
  fi
done

# Disable python bytecode generation to suppress __pycache__ folder creation
export PYTHONDONTWRITEBYTECODE=1

# Abort git transfers slower than 1 KB/s for 60 s, since git has no timeout,
# so that a stalled clone (e.g. py-torch with submodules) fails and is retried
export GIT_HTTP_LOW_SPEED_LIMIT=1000
export GIT_HTTP_LOW_SPEED_TIME=60

# Run a command that downloads data with up to 3 attempts and a backoff
# of 60 s and 120 s to bridge transient network issues
retry_download() {
  local attempt delay=60
  for attempt in 1 2 3; do
    "$@" && return 0
    if ((attempt < 3)); then
      echo "WARNING: Attempt ${attempt} of 3 failed, retrying in ${delay} seconds: $*"
      sleep "${delay}"
      delay=$((delay * 2))
    fi
  done
  return 1
}

# Print OS info if available
if [[ -f /etc/os-release ]]; then
  echo ""
  cat /etc/os-release
fi

# Check bash version
if ((BASH_VERSINFO < 4)); then
  echo ""
  echo "ERROR: The employed bash version ${BASH_VERSION} is too old (from 2004)"
  echo "       Install a newer bash version"
  if [[ "$(uname -s)" == "Darwin" ]]; then
    echo "HINT:  Use the bash command provided by Homebrew with Apple"
    echo "       /opt/homebrew/bin should precede /bin/bash in the PATH"
    echo "       In sourcing mode, run /opt/homebrew/bin/bash first before sourcing this script"
  fi
  ${EXIT_CMD} 1
elif ((BASH_VERSINFO < 5)); then
  echo -e "\nWARNING: The employed bash version ${BASH_VERSION} is quite old (from 2009)"
else
  echo -e "\nINFO: Using bash version ${BASH_VERSION}"
fi

# Check if the python3 version is new enough for spack
if ! python3 -c "import sys; sys.exit(not(sys.version_info >= (3, 10)))"; then
  echo ""
  echo "ERROR: Python version is NOT >= 3.10 (needed for Spack)"
  echo "       Found only $(python3 -V)"
  ${EXIT_CMD} 1
else
  echo -e "\nINFO: Found $(python3 -V)"
fi

# Default values
ASE_VERSION=""
BENCHMARK_PROFILE=""
BUILD_DEPS="if_needed"
BUILD_DEPS_ONLY="no"
BUILD_SHARED_LIBS="${BUILD_SHARED_LIBS:-ON}"
CHECK_CONVENTIONS="no"
CP2K_BUILD_TYPE="${CP2K_BUILD_TYPE:-Release}"
DEPS_BUILD_TYPE="${DEPS_BUILD_TYPE:-Release}"
CMAKE_FEATURE_FLAG_ALL="-DCP2K_USE_EVERYTHING=ON" # all features are activated by default
CMAKE_FEATURE_FLAGS="-DCP2K_BLAS_VENDOR=OpenBLAS" # LAPACK/BLAS from OpenBLAS by default
CMAKE_FEATURE_FLAG_MPI="-DCP2K_USE_MPI=ON"        # MPI is switched on by default
CMAKE_FEATURE_FLAGS_GPU="-DCP2K_USE_SPLA_GEMM_OFFLOADING=ON"
CMAKE_PRESET="native-gnu-x86_64"
CRAY="no"
CUDA_SM_CODE=0
GCC_VERSION="auto"
GPU_MODEL="none"
GROMACS_VERSION=""
HELP="no"
INSTALL_MESSAGE="NEVER"
MPI_MODE="mpich"
if command -v nproc &> /dev/null; then
  MAX_PROCS=$(nproc)
  NUM_PROCS=${NUM_PROCS:-${MAX_PROCS}}
else
  MAX_PROCS=-1
  NUM_PROCS=${NUM_PROCS:-8}
fi
NUM_PACKAGES=2
NVCC_VERSION=0
REBUILD_CP2K="no"
RUN_BENCHMARK="no"
RUN_TEST="no"
SED_PATTERN_LIST=""
TESTOPTS=""
TEST_ASE="no"
TEST_COVERAGE="no"
TEST_GROMACS="no"
USE_CACHE="folder"
USE_CUSOLVER_MP=""
USE_EXTERNALS="no"
USE_OPENCL="no"
VERBOSE=0
VERBOSE_FLAG="--quiet"
VERBOSE_MAKEFILE="OFF"
VERBOSE_SPACK=""

export CP2K_ENV="cp2k_env"
export CP2K_ROOT=${CP2K_ROOT:-${PWD}}
export CP2K_VERSION="${CP2K_VERSION:-psmp}"

# Retrieve CP2K revision if folder is a git repository
if CP2K_REVISION=$(git -C "${CP2K_ROOT}" rev-parse --short HEAD 2> /dev/null); then
  # Git succeeded, CP2K_REVISION is already set
  :
else
  CP2K_REVISION="unknown"
fi

export BUILD_PATH="${BUILD_PATH:-${CP2K_ROOT}}"
export INSTALL_PREFIX="${INSTALL_PREFIX:-${CP2K_ROOT}/install}"

# Parse flags
while [[ $# -gt 0 ]]; do
  case "$1" in
    -ase)
      if (($# > 1)); then
        ASE_VERSION="${2}"
      else
        echo "ERROR: No ASE version (branch or tag name) found for flag \"${1}\""
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -bd | --build_deps | --build_dependencies)
      BUILD_DEPS="always"
      shift 1
      ;;
    -bd_only | --build_deps_only | --build_dependencies_only)
      BUILD_DEPS="always"
      BUILD_DEPS_ONLY="yes"
      shift 1
      ;;
    -bp | --build_path)
      if (($# > 1)); then
        BUILD_PATH="$(realpath "${2}")"
      else
        echo "ERROR: No build path argument found for flag \"${1}\""
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -bsl | --build_static_libcp2k)
      BUILD_SHARED_LIBS="OFF"
      shift 1
      ;;
    -bt | --build_type)
      if (($# > 1)); then
        CP2K_BUILD_TYPE="${2}"
        case "${CP2K_BUILD_TYPE}" in
          Debug)
            CP2K_VERSION="${CP2K_VERSION/smp/dbg}"
            ;;
          Release | RelWithDebInfo)
            CP2K_VERSION="${CP2K_VERSION/dbg/smp}"
            ;;
        esac
      else
        echo "ERROR: No CMake build type argument found for flag \"${1}\" (e.g. Release)"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -cc | --check_conventions)
      CHECK_CONVENTIONS="yes"
      shift 1
      ;;
    -cray)
      CRAY="yes"
      shift 1
      ;;
    -cv | --cp2k_version)
      if (($# > 1)); then
        case "${2,,}" in
          pdbg | psmp | sdbg | ssmp | ssmp-static)
            CP2K_VERSION="${2,,}"
            # Set build type
            case "${CP2K_VERSION}" in
              pdbg | sdbg)
                CP2K_BUILD_TYPE="Debug"
                DEPS_BUILD_TYPE="RelWithDebInfo"
                ;;
              psmp | ssmp | ssmp-static)
                CP2K_BUILD_TYPE="Release"
                DEPS_BUILD_TYPE="Release"
                ;;
            esac
            # Disable MPI for a serial CP2K binary
            case "${CP2K_VERSION}" in
              sdbg | ssmp | ssmp-static)
                MPI_MODE="no"
                CMAKE_FEATURE_FLAG_MPI="-DCP2K_USE_MPI=OFF"
                # LibGint requires MPI
                CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_LIBGINT=OFF"
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"libgint@/ s/^ /#/'"
                ;;
            esac
            # Apply specific package selection for statically linked binaries
            case "${CP2K_VERSION}" in
              ssmp-static)
                CMAKE_FEATURE_FLAG_ALL="-DCP2K_USE_EVERYTHING=ON"
                for package in libfci libint2 libxc libxs spglib vori tblite; do
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_${package^^}=ON"
                done
                for package in ace deepmd gauxc greenx hdf5 libtorch pexsi trexio; do
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_${package^^}=OFF"
                done
                ;;
            esac
            ;;
          *)
            echo "ERROR: Invalid CP2K version \"${2}\" specified (choose pdbg, psmp, sdbg, ssmp, or ssmp-static)"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No argument found for flag \"${1}\" (choose pdbg, psmp, sdbg, ssmp, or ssmp-static)"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -df | --disable | --disable_feature | -ef | --enable | --enable_feature)
      if (($# > 1)); then
        case "${1}" in
          -df | --disable | --disable_feature)
            ON_OFF="OFF"
            SUBST="s/^ /#/'"
            ;;
          -ef | --enable | --enable_feature)
            ON_OFF="ON"
            SUBST="s/#/ /'"
            ;;
        esac
        case "${2,,}" in
          all)
            # Enable or disable all features
            CMAKE_FEATURE_FLAG_ALL="-DCP2K_USE_EVERYTHING=${ON_OFF}"
            for package in adios2 cosma deepmdkit dla-future dla-future-fortran elpa \
              gauxc greenx hdf5 libfabric libfci libint2 libvdwxc libsmeagol libvori \
              libxc libxs libxsmm mimic-mcl openpmd-api pace pexsi plumed py-torch sirius \
              spfft spglib spla tblite trexio; do
              SED_PATTERN_LIST+=" -e '/\s*-\s+\"${package}@/ ${SUBST}"
            done
            # dbcsr must use blas as fallback when libxs/libxsmm is disabled
            if [[ "${ON_OFF}" == "OFF" ]]; then
              SED_PATTERN_LIST+=" -e '/\s*-\s+\"smm=libxs\"/ s/libxs/blas/'"
            fi
            ;;
          ace | cosma | deepmd | dftd4 | dlaf | elpa | gauxc | greenx | hdf5 | libfci | libgint | \
            libint2 | libsmeagol | libtorch | libxc | libxs | mimic | openpmd | pexsi | plumed | \
            spglib | tblite | trexio | vori)
            CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_${2^^}=${ON_OFF}"
            # Translate package selection to sed pattern
            case "${2,,}" in
              ace)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"p${2,,}@/ ${SUBST}"
                ;;
              cosma | elpa | greenx | hdf5 | libfci | libgint | libsmeagol | libxc | pexsi | plumed | \
                spglib | trexio)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"${2,,}@/ ${SUBST}"
                ;;
              deepmd)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"${2,,}kit@/ ${SUBST}"
                if [[ "${ON_OFF}" == "ON" ]]; then
                  # DeePMD-kit requires libtorch
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_LIBTORCH=${ON_OFF}"
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"py-torch@/ ${SUBST}"
                fi
                ;;
              dftd4)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"${2,,}@/ ${SUBST}"
                if [[ "${ON_OFF}" == "ON" ]]; then
                  echo "INFO: tblite is disabled to avoid conflicts when dftd4 is used"
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_TBLITE=OFF"
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"tblite@/ s/^ /#/'"
                fi
                ;;
              dlaf)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"dla-future.*@/ ${SUBST}"
                if [[ "${ON_OFF}" == "ON" ]]; then
                  SED_PATTERN_LIST+=" -e 's/\~dlaf/\+dlaf/'"
                else
                  SED_PATTERN_LIST+=" -e 's/\+dlaf/\~dlaf/'"
                fi
                ;;
              gauxc)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"${2,,}@/ ${SUBST}"
                if [[ "${ON_OFF}" == "ON" ]]; then
                  # GauXC requires libtorch
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_LIBTORCH=${ON_OFF}"
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"py-torch@/ ${SUBST}"
                fi
                ;;
              libint2)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"libint@/ ${SUBST}"
                ;;
              libtorch)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"py-torch@/ ${SUBST}"
                if [[ "${ON_OFF}" == "OFF" ]]; then
                  # DeePMD-kit and GauXC require libtorch
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_DEEPMD=${ON_OFF}"
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"deepmdkit@/ ${SUBST}"
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_GAUXC=${ON_OFF}"
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"gauxc@/ ${SUBST}"
                fi
                ;;
              libxs)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"libxs@/ ${SUBST}"
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"libxsmm@/ ${SUBST}"
                if [[ "${ON_OFF}" == "OFF" ]]; then
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"smm=${2,,}\"/ s/${2,,}/blas/'"
                fi
                ;;
              mimic)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"mimic-mcl@/ ${SUBST}"
                ;;
              openpmd | adios2)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"adios2@/ ${SUBST}"
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"openpmd-api@/ ${SUBST}"
                ;;
              tblite)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"${2,,}@/ ${SUBST}"
                if [[ "${ON_OFF}" == "ON" ]]; then
                  echo "INFO: dftd4 is disabled to avoid conflicts when tblite is used"
                  CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_DFTD4=OFF"
                  SED_PATTERN_LIST+=" -e '/\s*-\s+\"dftd4@/ s/^ /#/'"
                fi
                ;;
              vori)
                SED_PATTERN_LIST+=" -e '/\s*-\s+\"lib${2,,}@/ ${SUBST}"
                ;;
            esac
            ;;
          libvdwxc | spfft | spla | sirius)
            echo "WARNING: You have enabled or disabled one of the packages libvdwxc, spfft, spla, sirius"
            echo "         which means that the other packages will also be enabled or disabled"
            CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_LIBVDWXC=${ON_OFF} -DCP2K_USE_SpFFT=${ON_OFF}"
            CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_SPLA=${ON_OFF} -DCP2K_USE_SIRIUS=${ON_OFF}"
            SED_PATTERN_LIST+=" -e '/\s*-\s+\"libvdwxc@/ ${SUBST}"
            SED_PATTERN_LIST+=" -e '/\s*-\s+\"spfft@/ ${SUBST}"
            SED_PATTERN_LIST+=" -e '/\s*-\s+\"spla@/ ${SUBST}"
            SED_PATTERN_LIST+=" -e '/\s*-\s+\"sirius@/ ${SUBST}"
            ;;
          cusolver_mp)
            USE_CUSOLVER_MP="${ON_OFF}"
            CMAKE_FEATURE_FLAGS_GPU+=" -DCP2K_USE_${2^^}=${ON_OFF}"
            SED_PATTERN_LIST+=" -e '/\s*-\s+\"cusolvermp@/ ${SUBST}"
            ;;
          cray_pm_accel_energy | spla_gemm_offloading | unified_memory)
            CMAKE_FEATURE_FLAGS_GPU+=" -DCP2K_USE_${2^^}=${ON_OFF}"
            ;;
          dbm_gpu | elpa_gpu | grid_gpu | libxc_gpu | pw_gpu)
            CMAKE_FEATURE_FLAGS_GPU+=" -DCP2K_ENABLE_${2^^}=${ON_OFF}"
            ;;
          none)
            # do nothing
            ;;
          *)
            echo "ERROR: Unknown CP2K feature \"${2}\" specified"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No feature found for flag \"${1}\""
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -gm | -gpu | --gpu_model)
      if (($# > 1)); then
        case "${2^^}" in
          P100 | V100 | T400 | A100 | A40 | H100 | H200 | GH200 | B200)
            GPU_MODEL="${2^^}"
            case "${GPU_MODEL}" in
              P100)
                CUDA_SM_CODE=60
                ;;
              V100)
                CUDA_SM_CODE=70
                ;;
              T400)
                CUDA_SM_CODE=75
                ;;
              A100)
                CUDA_SM_CODE=80
                ;;
              A40)
                CUDA_SM_CODE=86
                ;;
              H100 | H200 | GH200)
                CUDA_SM_CODE=90
                ;;
              B200)
                CUDA_SM_CODE=100
                ;;
            esac
            ;;
          60 | 70 | 75 | 80 | 86 | 87 | 89 | 90 | 100 | 120 | 121)
            CUDA_SM_CODE=${2}
            ;;
          NONE)
            GPU_MODEL="${2,,}"
            ;;
          *)
            echo -e "\nERROR: Unknown GPU model \"${2}\" specified (choose <CUDA SM code>, P100, V100, T400, A100, A40, H100, H200, GH200, B200 or none)\n"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo -e "\nERROR: No argument found for flag \"${1}\" (choose <CUDA SM code>, P100, V100, T400, A100, A40, H100, H200, GH200, B200 or none)\n"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -gromacs)
      if (($# > 1)); then
        GROMACS_VERSION="${2}"
      else
        echo "ERROR: No GROMACS version (branch or tag name) found for flag \"${1}\" (e.g. v2026.3)"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -gv | --gcc_version)
      if (($# > 1)); then
        case "${2}" in
          1[0-6])
            GCC_VERSION="${2}"
            ;;
          *)
            echo "ERROR: Invalid GCC version \"${2}\" specified (choose from 10 to 16)"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No argument found for flag \"${1}\" (choose a GCC version)"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -h | --help)
      HELP="yes"
      shift 1
      ;;
    -ip | --install_path | --install_prefix)
      if (($# > 1)); then
        INSTALL_PREFIX="$(realpath "${2}")"
      else
        echo "ERROR: No install path argument found for flag \"${1}\""
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -j)
      if (($# > 1)); then
        case "${2}" in
          -*)
            shift 1
            ;;
          [0-9]*)
            NUM_PROCS="${2}"
            shift 2
            ;;
          *)
            echo "ERROR: The -j flag can only be followed by an integer number, found \"${2}\""
            ${EXIT_CMD} 1
            ;;
        esac
      else
        shift 1
      fi
      ;;
    -j[0-9]*)
      NUM_PROCS="${1#-j}"
      shift 1
      ;;
    -mpi | --mpi_mode)
      if (($# > 1)); then
        case "${2,,}" in
          mpich | openmpi)
            CMAKE_FEATURE_FLAG_MPI="-DCP2K_USE_MPI=ON"
            MPI_MODE="${2,,}"
            ;;
          no | none | off)
            CMAKE_FEATURE_FLAG_MPI="-DCP2K_USE_MPI=OFF"
            MPI_MODE="no"
            ;;
          *)
            echo "ERROR: Unknown MPI mode \"${2}\" specified (choose mpich, openmpi, or no)"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No argument found for flag \"${1}\""
        echo "       The MPI mode is required (choose mpich,  openmpi, or no)"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -np | --num_packages)
      if (($# > 1)); then
        case "${2}" in
          -*)
            shift 1
            ;;
          [0-9]*)
            NUM_PACKAGES="${2}"
            shift 2
            ;;
          *)
            echo "ERROR: The -np flag can only be followed by an integer number, found \"${2}\""
            ${EXIT_CMD} 1
            ;;
        esac
      else
        shift 1
      fi
      ;;
    -opencl)
      USE_OPENCL="yes"
      shift 1
      ;;
    -preset)
      if (($# > 1)); then
        case "${2}" in
          native-gnu-x86_64 | native-gnu-arm64 | native-intel | none)
            CMAKE_PRESET="${2}"
            ;;
          *)
            echo "ERROR: Invalid preset \"${2}\" specified"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No CMake preset found for flag \"${1}\""
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -rc | --rebuild_cp2k)
      REBUILD_CP2K="yes"
      shift 1
      ;;
    -t | --test)
      RUN_TEST="yes"
      if (($# > 1)); then
        TESTOPTS="${2}"
      else
        echo "ERROR: No argument found for flag \"${1}\""
        echo "       A string argument with the TESTOPTS (even an empty one \"\") is required"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -ta | --test_ase)
      TEST_ASE="yes"
      shift 1
      ;;
    -tc | --test_coverage)
      TEST_COVERAGE="yes"
      shift 1
      ;;
    -tg | --test_gromacs)
      TEST_GROMACS="yes"
      shift 1
      ;;
    -tp | --test_performance)
      RUN_BENCHMARK="yes"
      if (($# > 1)); then
        case "${2,,}" in
          cuda_* | default | openmp)
            BENCHMARK_PROFILE="${2,,}"
            ;;
          *)
            echo "ERROR: Invalid benchmark profile \"${2}\" specified (choose e.g. openmp)"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No benchmark profile found for flag \"${1}\""
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -uc | --use_cache)
      if (($# > 1)); then
        case "${2,,}" in
          folder | minio | no | none)
            USE_CACHE="${2,,}"
            ;;
          *)
            echo "ERROR: Invalid cache mode \"${2}\" specified (choose folder, minio or no)"
            ${EXIT_CMD} 1
            ;;
        esac
      else
        echo "ERROR: No argument found for flag \"${1}\" (choose folder, minio or no)"
        ${EXIT_CMD} 1
      fi
      shift 2
      ;;
    -ue | --use_externals)
      USE_EXTERNALS="yes"
      shift 1
      ;;
    -v | --verbose)
      VERBOSE=1
      INSTALL_MESSAGE="LAZY"
      VERBOSE_FLAG="--verbose"
      VERBOSE_MAKEFILE="ON"
      VERBOSE_SPACK="--verbose"
      shift 1
      ;;
    --)
      shift 1
      break
      ;;
    -*)
      echo "ERROR: Unknown option \"${1}\" specified"
      ${EXIT_CMD} 1
      ;;
    *)
      break
      ;;
  esac
done

# Remove leading zeros from NUM_PACKAGES and NUM_PROCS
NUM_PACKAGES=$(awk '{print $1+0}' <<< "${NUM_PACKAGES}")
NUM_PROCS=$(awk '{print $1+0}' <<< "${NUM_PROCS}")

# Check if we are working within a docker or podman container
[[ -f /.dockerenv || -f /run/.containerenv ]] && IN_CONTAINER="yes" || IN_CONTAINER="no"

# Assemble CMake feature flag list
CMAKE_FEATURE_FLAGS="${CMAKE_FEATURE_FLAG_ALL} ${CMAKE_FEATURE_FLAG_MPI} ${CMAKE_FEATURE_FLAGS}"

# DLA-Future does not work with MPICH yet
case "${MPI_MODE}" in
  mpich | openmpi)
    if [[ "${CMAKE_FEATURE_FLAGS}" == *"-DCP2K_USE_EVERYTHING=ON"* ]] ||
      [[ "${CMAKE_FEATURE_FLAGS}" == *"-DCP2K_USE_DLAF=ON"* ]]; then
      echo -e "\nINFO: DLA-Future does not work with ${MPI_MODE^^} yet and is disabled"
      CMAKE_FEATURE_FLAGS+=" -DCP2K_USE_DLAF=OFF"
      SED_PATTERN_LIST+=" -e '/\s*-\s+\"dla-future.*@/ s/^ /#/'"
      SED_PATTERN_LIST+=" -e 's/\+dlaf/\~dlaf/'"
    fi
    ;;
esac

# Clean CMake feature flag list from repeated entries and keep only the last definition
declare -A last=()
order=()
# First pass: record the last occurrence of each flag
for flag in ${CMAKE_FEATURE_FLAGS}; do
  name=${flag%=*}
  last[${name}]=${flag}
  order+=("${name}")
done
# Second pass: output only the last definition per flag
# but respecting original order of last appearance
declare -A seen=()
out=()
for name in "${order[@]}"; do
  if [[ -z ${seen[${name}]+_} ]]; then
    seen[${name}]=1
    out+=("${last[${name}]}")
  fi
done
CMAKE_FEATURE_FLAGS="$(printf '%s\n' "${out[*]}")"

# Set default GROMACS version if GROMACS/CP2K testing is requested
if [[ ${TEST_GROMACS} == "yes" ]]; then
  GROMACS_VERSION=${GROMACS_VERSION:-v2026.3}
fi

# Set default ASE version if ASE/CP2K testing is requested
if [[ ${TEST_ASE} == "yes" ]]; then
  ASE_VERSION=${ASE_VERSION:-master}
fi

# Perform setup for coding conventions check
if [[ "${CHECK_CONVENTIONS}" == "yes" ]]; then
  if [[ "${CP2K_VERSION}" != "psmp" ]]; then
    echo ""
    echo "WARNING: Convention checking implies CP2K_VERSION \"psmp\" but found \"${CP2K_VERSION}\""
    echo "         CP2K_VERSION is set to \"psmp\""
    echo ""
    CP2K_VERSION="psmp"
  fi
  CP2K_BUILD_TYPE="RelWithDebInfo"
  CMAKE_PRESET="conventions"
  Fortran_COMPILER_LAUNCHER="${CP2K_ROOT}/tools/conventions/redirect_gfortran_output.py"
else
  Fortran_COMPILER_LAUNCHER=""
fi

# Test coverage and generate a coverage report
if [[ "${TEST_COVERAGE}" == "yes" ]]; then
  if [[ "${CP2K_VERSION}" != "psmp" ]]; then
    echo ""
    echo "WARNING: Coverage testing implies CP2K_VERSION \"psmp\" but found \"${CP2K_VERSION}\""
    echo "         CP2K_VERSION is set to \"psmp\""
    echo ""
    CP2K_VERSION="psmp"
  fi
  if ! command -v lcov &> /dev/null; then
    echo -e "\nERROR: The package lcov is mandatory for a coverage test"
    echo -e "       Install the missing package and re-run the script\n"
    ${EXIT_CMD} 1
  fi
  CP2K_BUILD_TYPE="RelWithDebInfo"
  CMAKE_PRESET="coverage"
  RUN_TEST="yes"
  TESTOPTS+=" --ompthreads=1 --keepalive"
fi

export ASE_VERSION BENCHMARK_PROFILE BUILD_DEPS BUILD_DEPS_ONLY BUILD_SHARED_LIBS CHECK_CONVENTIONS CMAKE_FEATURE_FLAGS \
  CMAKE_FEATURE_FLAGS_GPU CP2K_BUILD_TYPE CP2K_REVISION CRAY CUDA_SM_CODE DEPS_BUILD_TYPE Fortran_COMPILER_LAUNCHER \
  GCC_VERSION GPU_MODEL GROMACS_VERSION IN_CONTAINER INSTALL_MESSAGE MPI_MODE NUM_PACKAGES NUM_PROCS \
  REBUILD_CP2K RUN_BENCHMARK RUN_TEST TEST_COVERAGE TEST_ASE TEST_GROMACS TESTOPTS USE_CACHE USE_OPENCL VERBOSE \
  VERBOSE_FLAG VERBOSE_MAKEFILE VERBOSE_SPACK

# Show help if requested
if [[ "${HELP}" == "yes" ]]; then
  echo ""
  echo "Usage: ${SCRIPT_NAME} [-bd | --build_deps]"
  echo "                    [-ase ASE_VERSION]"
  echo "                    [-bd_only | --build_deps_only]"
  echo "                    [-bp | --build_path PATH]"
  echo "                    [-bsl | --build_static_libcp2k]"
  echo "                    [-bt | --build_type (Debug | Release | RelWithDebInfo)]"
  echo "                    [-cc | --check_conventions]"
  echo "                    [-cray]"
  echo "                    [-cv | --cp2k_version (pdbg | psmp | sdbg | ssmp | ssmp-static)]"
  echo "                    [-df | --disable | --disable_feature (all | FEATURE | PACKAGE | none)]"
  echo "                    [-ef | --enable | --enable_feature (all | FEATURE | PACKAGE | none)]"
  echo "                    [-gm | -gpu  | --gpu_model (<CUDA SM code> | P100 | V100 | T400 | A100 | H100 | H200 | GH200 | B200 | none)]"
  echo "                    [-gromacs GROMACS_VERSION]"
  echo "                    [-gv | --gcc_version (10 | 11 | 12 | 13 | 14 | 15 | 16)]"
  echo "                    [-h | --help]"
  echo "                    [-ip | --install_path PATH]"
  echo "                    [-j #PROCESSES]"
  echo "                    [-mpi | --mpi_mode (mpich | no | openmpi)]"
  echo "                    [-np | --num_packages #PACKAGES]"
  echo "                    [-opencl]"
  echo "                    [-preset (native-gnu-x86_64 | native-gnu-arm64 | native-intel | none)]"
  echo "                    [-rc | --rebuild_cp2k]"
  echo "                    [-t | --test \"TESTOPTS\"]"
  echo "                    [-ta | --test_ase]"
  echo "                    [-tc | --test_coverage]"
  echo "                    [-tg | --test_gromacs]"
  echo "                    [-tp | --test_performance \"BENCHMARK_PROFILE\"]"
  echo "                    [-uc | --use_cache (folder | minio | no | none)]"
  echo "                    [-ue | --use_externals]"
  echo "                    [-v | --verbose]"
  echo ""
  echo "Flags:"
  echo " -ase                  : Build CP2K with ASE support"
  echo " --build_deps          : Force a rebuild of all CP2K dependencies from scratch (removes the spack folder)"
  echo " --build_deps_only     : Rebuild ONLY the CP2K dependencies from scratch (removes the spack folder)"
  echo " --build_path          : Define the CP2K build path (default: ${CP2K_ROOT})"
  echo " --build_static_libcp2k: Build a static CP2K library libcp2k.a instead of the default shared one libcp2k.so"
  echo " --build_type          : Set preferred CMake build type for CP2K (default: \"Release\")"
  echo " --check_conventions   : Check compliance with CP2K's coding conventions"
  echo " --cp2k_version        : CP2K version to be built (default: \"psmp\")"
  echo " -cray                 : Use Cray specific spack configuration"
  echo " --enable_feature      : Enable feature or package (default: all)"
  echo " --disable_feature     : Disable feature or package"
  echo " -gromacs              : Build GROMACS with CP2K support"
  echo " --help                : Print this help information"
  echo " --gcc_version         : Use the specified GCC version (default: automatically decided by spack)"
  echo " --gpu_model           : Select GPU model (default: none)"
  echo " --install_path        : Define the CP2K installation path (default: ./install)"
  echo " -j                    : Maximum number of processes (CPU cores) used in parallel"
  echo "                         If the variable OMP_NUM_THREADS is set and the -j flag is not supplied, then"
  echo "                         the maximum number of processes is defined by OMP_NUM_THREADS"
  echo " --mpi_mode            : Set preferred MPI mode (default: \"mpich\")"
  echo " --num_packages        : Maximum number of packages built by spack in parallel (default: 4)"
  echo " -opencl               : Enable the use of the Open Computing Language (OpenCL)"
  echo " -preset               : Use a CMake configure preset, see \"cmake --list-presets\" (default: native-gnu-x86_64)"
  echo " --rebuild_cp2k        : Rebuild CP2K: removes the build folder (default: no)"
  echo " --test                : Perform a regression test run after a successful build"
  echo " --test_ase            : Build and test CP2K with ASE support"
  echo " --test_coverage       : Analyse the code coverage and generate a coverage report"
  echo " --test_gromacs        : Build and test GROMACS with CP2K support"
  echo " --test_performance    : Perform a benchmark run after a successful build"
  echo " --use_cache           : Use a \"folder\", a \"MinIO\" object storage container (requires podman) or \"no\" cache"
  echo "                         Set the environment variable SPACK_CACHE to specify the folder name, e.g."
  echo "                         SPACK_CACHE=\"file://${CP2K_ROOT}/spack_cache\" (default)"
  echo " --use_externals       : Use external packages installed on the host system. This results in much"
  echo "                         faster build times, but it can also cause conflicts with outdated packages"
  echo "                         pulled in from the host system, e.g. old python or gcc versions"
  echo " --verbose             : Write verbose output"
  echo ""
  echo "Hints:"
  echo " - Remove the folder ${CP2K_ROOT}/build to (re)build CP2K from scratch"
  echo "   (see also --rebuild_cp2k flag)"
  echo " - Remove the folder ${CP2K_ROOT}/spack to (re)build CP2K and all its dependencies from scratch"
  echo "   (see also --build_deps flag)"
  echo " - The folder ${CP2K_ROOT}/install is updated after each successful run"
  echo ""
  echo "Packages: all | ace | cosma | deepmd | dftd4 | dlaf | elpa | gauxc | greenx | hdf5 | libfci |"
  echo "          libgint | libint2 | libsmeagol | libtorch | libvdwxc | libxs | mimic | openpmd | pexsi | plumed |"
  echo "          sirius | spfft | spglib | spla | tblite | trexio | vori "
  echo ""
  echo "Features: cray_pm_accel_energy | cusolver_mp | dbm_gpu | elpa_gpu | grid_gpu | libxc_gpu | pw_gpu |"
  echo "          spla_gemm_offloading | unified_memory"
  echo ""
  ${EXIT_CMD}
fi

echo ""
if [[ -n ${ASE_VERSION} ]]; then
  echo "ASE_VERSION         = ${ASE_VERSION}"
fi
echo "BUILD_DEPS          = ${BUILD_DEPS}"
echo "BUILD_DEPS_ONLY     = ${BUILD_DEPS_ONLY}"
echo "BUILD_PATH          = ${BUILD_PATH}"
echo "BUILD_SHARED_LIBS   = ${BUILD_SHARED_LIBS}"
echo "CHECK_CONVENTIONS   = ${CHECK_CONVENTIONS}"
echo "CMAKE_PRESET        = ${CMAKE_PRESET}"
echo "CP2K_BUILD_TYPE     = ${CP2K_BUILD_TYPE}"
echo "CP2K_REVISION       = ${CP2K_REVISION}"
echo "CP2K_VERSION        = ${CP2K_VERSION}"
echo "CRAY                = ${CRAY}"
echo "DEPS_BUILD_TYPE     = ${DEPS_BUILD_TYPE}"
echo "GCC_VERSION         = ${GCC_VERSION}"
if [[ -n ${GROMACS_VERSION} ]]; then
  echo "GROMACS_VERSION     = ${GROMACS_VERSION}"
fi
if ((CUDA_SM_CODE > 0)); then
  echo "GPU                 = ${GPU_MODEL} (CUDA SM code: ${CUDA_SM_CODE})"
else
  echo "GPU                 = ${GPU_MODEL}"
fi
echo "INSTALL_PREFIX      = ${INSTALL_PREFIX}"
echo "INSTALL_MESSAGE     = ${INSTALL_MESSAGE}"
echo "IN_CONTAINER        = ${IN_CONTAINER}"
echo "MPI_MODE            = ${MPI_MODE}"
echo "NUM_PACKAGES        = ${NUM_PACKAGES} (packages are built by spack concurrently)"
echo "NUM_PROCS           = ${NUM_PROCS} (processes)"
echo "Physical cores      = $(lscpu -p=Core,Socket | grep -v '#' | sort -u | wc -l) (host view)"
echo "REBUILD_CP2K        = ${REBUILD_CP2K}"
echo "RUN_BENCHMARK       = ${RUN_BENCHMARK}"
if [[ "${RUN_BENCHMARK}" == "yes" ]]; then
  case ${CP2K_VERSION} in
    psmp)
      echo "BENCHMARK_PROFILE   = ${BENCHMARK_PROFILE}"
      ;;
    *)
      echo -e "\nERROR: Performance test runs are supported only for CP2K_VERSION \"psmp\", found version \"${CP2K_VERSION}\"\n"
      ${EXIT_CMD} 1
      ;;
  esac
fi
echo "RUN_TEST            = ${RUN_TEST}"
if [[ "${RUN_TEST}" == "yes" ]]; then
  echo "TESTOPTS            = \"${TESTOPTS}\""
fi
echo "TEST_ASE            = ${TEST_ASE}"
echo "TEST_COVERAGE       = ${TEST_COVERAGE}"
echo "TEST_GROMACS        = ${TEST_GROMACS}"
echo "USE_CACHE           = ${USE_CACHE}"
echo "USE_EXTERNALS       = ${USE_EXTERNALS}"
echo "USE_OPENCL          = ${USE_OPENCL}"
echo "VERBOSE_FLAG        = ${VERBOSE_FLAG}"
echo "VERBOSE_MAKEFILE    = ${VERBOSE_MAKEFILE}"
echo "VERBOSE             = ${VERBOSE}"
if (($# > 0)); then
  echo -e "\nRemaining args   =" "$@" "(not used)"
fi
echo ""
echo "LD_LIBRARY_PATH     = ${LD_LIBRARY_PATH:-}"
echo ""
echo "PATH                = ${PATH:-}"
echo ""
echo "CMAKE_FEATURE_FLAGS = ${CMAKE_FEATURE_FLAGS}"
echo ""

((VERBOSE > 0)) && echo -e "SED_PATTERN_LIST    = ${SED_PATTERN_LIST}\n"

# Check if a valid number for the packages to be built by spack in parallel is given
if ((NUM_PACKAGES < 1)); then
  echo -e "\nERROR: The requested number of packages to be built by spack in parallel should be larger than 0, found \"${NUM_PACKAGES}\""
  ${EXIT_CMD} 1
elif ((NUM_PROCS > 0)) && ((NUM_PACKAGES > NUM_PROCS)); then
  echo -e "\nERROR: The requested number of packages to be built in parallel by spack (${NUM_PACKAGES}) is larger than the requested number of processes (${NUM_PROCS})"
  ${EXIT_CMD} 1
fi

# Check if a valid number of processes is requested
if ((NUM_PROCS < 1)); then
  echo "ERROR: The requested number of processes should be larger than 0, found \"${NUM_PROCS}\""
  ${EXIT_CMD} 1
elif ((MAX_PROCS > 0)) && ((NUM_PROCS > MAX_PROCS)); then
  echo "WARNING: The requested number of processes (${NUM_PROCS}) is larger than the detected number of CPU cores (${MAX_PROCS})"
fi

# Check if a valid CMake build type is selected for the dependencies
case "${DEPS_BUILD_TYPE^}" in
  Release | RelWithDebInfo)
    true
    ;;
  Debug)
    echo "ERROR: The CMake build type \"${DEPS_BUILD_TYPE}\" is not supported for building the dependencies"
    ${EXIT_CMD} 1
    ;;
  *)
    echo "ERROR: Invalid CMake build type \"${DEPS_BUILD_TYPE}\" selected for building the dependencies"
    ${EXIT_CMD} 1
    ;;
esac

# Check if a valid CMake build type is selected for CP2K
case "${CP2K_BUILD_TYPE^}" in
  Debug | Release | RelWithDebInfo)
    true
    ;;
  *)
    echo "ERROR: Invalid CMake build type \"${CP2K_BUILD_TYPE}\" selected for building CP2K"
    ${EXIT_CMD} 1
    ;;
esac

# Check if a valid MPI type is selected
case "${MPI_MODE}" in
  mpich | openmpi)
    if [[ "${CP2K_VERSION}" == "sdbg" || "${CP2K_VERSION}" == "ssmp"* ]]; then
      echo "ERROR: MPI type \"${MPI_MODE}\" specified for building a serial CP2K binary"
      ${EXIT_CMD} 1
    fi
    USE_MPI="ON"
    ;;
  no)
    if [[ "${CP2K_VERSION}" == "pdbg" || "${CP2K_VERSION}" == "psmp" ]]; then
      echo "ERROR: MPI type \"${MPI_MODE}\" specified for building an MPI-parallel CP2K binary"
      ${EXIT_CMD} 1
    fi
    USE_MPI="OFF"
    ;;
  *)
    echo "ERROR: Invalid MPI type \"${MPI_MODE}\" selected"
    echo "       Choose from (mpich | no | openmpi)"
    ${EXIT_CMD} 1
    ;;
esac

# cuSOLVERMp requires both CUDA and MPI support.
if [[ "${USE_CUSOLVER_MP}" == "ON" ]]; then
  if [[ "${MPI_MODE}" == "no" ]]; then
    echo -e "ERROR: The feature CUSOLVER_MP is not available for building serial CP2K binaries (${CP2K_VERSION})\n"
    ${EXIT_CMD} 1
  fi
  if ((CUDA_SM_CODE == 0)); then
    echo -e "ERROR: The feature CUSOLVER_MP requires CUDA support (specify --gpu_model)\n"
    ${EXIT_CMD} 1
  fi
fi

# Check if CP2K_VERSION and the selected features are compatible
case "${CP2K_VERSION}" in
  ssmp | ssmp-static)
    for package in cosma dlaf elpa libfabric libgint libsmeagol mimic openpmd pexsi plumed sirius spla; do
      if [[ "${CMAKE_FEATURE_FLAGS}" == *" -DCP2K_USE_${package^^}=ON"* ]]; then
        echo -e "ERROR: The feature ${package^^} is not available for building serial CP2K binaries (${CP2K_VERSION})\n"
        ${EXIT_CMD} 1
      fi
    done
    # Further exclusions are needed for statically linked serial CP2K binaries
    if [[ "${CP2K_VERSION}" == "ssmp-static" ]]; then
      for package in ace deepmd greenx hdf5 libtorch trexio; do
        if [[ "${CMAKE_FEATURE_FLAGS}" == *" -DCP2K_USE_${package^^}=ON"* ]]; then
          echo -e "ERROR: The feature ${package^^} is not available for building statically linked serial CP2K binaries (${CP2K_VERSION})\n"
          ${EXIT_CMD} 1
        fi
      done
    fi
    ;;
esac

# Perform CUDA GPU related settings
if ((CUDA_SM_CODE > 0)); then
  if command -v nvcc &> /dev/null; then
    CUDA_VERSION=$(nvcc -V | sed -n 's/.*release \([0-9.]*\).*/\1/p')
    NVCC_VERSION=$(awk -v x="${CUDA_VERSION}" 'BEGIN{print 10*x}')
  else
    echo -e "\nERROR: No CUDA toolkit installation found (nvcc compiler not found)\n"
    ${EXIT_CMD} 1
  fi
  # Check if the selected CUDA SM code is valid when the nvidia-smi command is available
  if command -v nvidia-smi &> /dev/null; then
    echo -e "NVIDIA driver installation found:\n"
    nvidia-smi
    HOST_CUDA_SM_CODE=$(nvidia-smi --query-gpu=compute_cap --format=csv,noheader | tail -n 1 | awk '{print 10*$1}')
    if ((CUDA_SM_CODE > HOST_CUDA_SM_CODE)); then
      echo ""
      echo "ERROR: The requested CUDA SM code (${CUDA_SM_CODE}) is larger than the maximum"
      echo "       CUDA SM code (${HOST_CUDA_SM_CODE}) supported by the host system"
      echo ""
      ${EXIT_CMD} 1
    fi
  else
    echo "INFO: No NVIDIA driver installation found (nvidia-smi not found)"
  fi
  # Check GPU support by the CUDA SDK
  if ((NVCC_VERSION < 128)) && ((CUDA_SM_CODE > 90)); then
    echo ""
    echo "ERROR: The CUDA SDK version ${NVCC_VERSION} does not support GPUs with a"
    echo "       CUDA SM code larger than 90 (found ${CUDA_SM_CODE})"
    echo ""
    ${EXIT_CMD} 1
  fi
  if ((NVCC_VERSION > 129)) && ((CUDA_SM_CODE < 75)); then
    echo ""
    echo "ERROR: The CUDA SDK version ${NVCC_VERSION} does not support GPUs with a"
    echo "       CUDA SM code smaller than 75 (found ${CUDA_SM_CODE})"
    echo ""
    ${EXIT_CMD} 1
  fi
  CMAKE_CUDA_FLAGS="-DCP2K_USE_ACCEL=CUDA"
  CMAKE_CUDA_FLAGS+=" -DCMAKE_CUDA_HOST_COMPILER=$(which g++)"
  CMAKE_CUDA_FLAGS+=" -DCP2K_WITH_GPU=${GPU_MODEL}"
  CMAKE_CUDA_FLAGS+=" -DCMAKE_CUDA_ARCHITECTURES=${CUDA_SM_CODE}"
  CMAKE_CUDA_FLAGS+=" ${CMAKE_FEATURE_FLAGS_GPU}"
  out=()
  for flag in ${CMAKE_CUDA_FLAGS}; do
    [[ ${seen[${flag}]+_} ]] || {
      seen[${flag}]=1
      out+=("${flag}")
    }
  done
  CMAKE_CUDA_FLAGS="$(printf '%s\n' "${out[*]}")"
  echo -e "\nCMAKE_CUDA_FLAGS    = ${CMAKE_CUDA_FLAGS}"
  [[ -n "${CUDA_VERSION:-}" ]] && echo -e "\nCUDA_VERSION        = ${CUDA_VERSION} (nvcc compiler)"
  [[ -n "${CUDA_HOME:-}" ]] && echo -e "\nCUDA_HOME           = ${CUDA_HOME}"
  echo ""
else
  CMAKE_CUDA_FLAGS="-DCP2K_USE_ACCEL=OFF"
fi
export CMAKE_CUDA_FLAGS

# Retrieve and print available resources
free -h
echo ""
ulimit -c 0 -s unlimited
ulimit -a
echo ""

### Build CP2K dependencies with Spack if needed or requested ###

# Spack version
export SPACK_VERSION="${SPACK_VERSION:-1.2.2}"
export SPACK_BUILD_PATH="${BUILD_PATH}/spack"
export SPACK_ROOT="${SPACK_BUILD_PATH}/spack"

# Isolate user configuration for spack
export SPACK_DISABLE_LOCAL_CONFIG=true
export SPACK_USER_CONFIG_PATH="${SPACK_BUILD_PATH}"
export SPACK_USER_CACHE_PATH="${SPACK_BUILD_PATH}/cache"

# Define the CP2K spack configuration file
export CP2K_CONFIG_FILE="${SPACK_BUILD_PATH}/cp2k_deps_${CP2K_VERSION:0:1}${CP2K_VERSION:4}.yaml"

# If requested, remove the spack folder for (re)building all CP2K dependencies
if [[ "${BUILD_DEPS}" == "always" ]]; then
  for folder in ${SPACK_BUILD_PATH} ${BUILD_PATH}/build ${INSTALL_PREFIX}; do
    if [[ -d "${folder}" ]]; then
      echo "Removing folder \"${folder}\""
      rm -rf "${folder}"
    fi
  done
fi

# If requested, remove the build folder for (re)building CP2K
if [[ "${REBUILD_CP2K}" == "yes" ]]; then
  for folder in ${BUILD_PATH}/build ${INSTALL_PREFIX}; do
    if [[ -d "${folder}" ]]; then
      echo "Removing folder \"${folder}\""
      rm -rf "${folder}"
    fi
  done
fi

# An incomplete build already contains the Spack installation, source cache,
# environment, and every successfully installed dependency. Re-enter the
# setup/install path until the completion marker is written.
if [[ ! -f "${SPACK_BUILD_PATH}/BUILD_DEPENDENCIES_COMPLETED" ]]; then

  if [[ -d "${SPACK_BUILD_PATH}" ]]; then
    echo "INFO: Resuming incomplete CP2K dependency build in ${SPACK_BUILD_PATH}"
  else
    echo "INFO: Creating local Spack build directory ${SPACK_BUILD_PATH}"
  fi
  mkdir -p "${SPACK_BUILD_PATH}"
  cd "${SPACK_BUILD_PATH}" || ${EXIT_CMD} 1

  # Reset the spack environment
  unset SPACK_ENV

  # Install Spack only when the local bootstrap is absent. wget --continue
  # also retains a partially downloaded release archive across interruptions.
  if [[ ! -d "${SPACK_ROOT}" ]]; then
    echo "Installing Spack ${SPACK_VERSION}"
    if ! retry_download wget -nv -c --timeout=60 --tries=2 "https://github.com/spack/spack/releases/download/v${SPACK_VERSION}/spack-${SPACK_VERSION}.tar.gz"; then
      echo "ERROR: Downloading Spack ${SPACK_VERSION} failed"
      ${EXIT_CMD} 1
    fi
    if ! tar -xzf "spack-${SPACK_VERSION}.tar.gz"; then
      echo "ERROR: Extracting Spack ${SPACK_VERSION} failed"
      ${EXIT_CMD} 1
    fi
    if ! mv -f "${SPACK_BUILD_PATH}/spack-${SPACK_VERSION}" "${SPACK_ROOT}"; then
      echo "ERROR: Installing Spack ${SPACK_VERSION} failed"
      ${EXIT_CMD} 1
    fi
    rm -f "spack-${SPACK_VERSION}.tar.gz"
  fi
  export PATH="${SPACK_ROOT}/bin:${PATH}"

  # Create cache folder for user configuration
  mkdir -p "${SPACK_USER_CACHE_PATH}"

  # Set Spack cache (folder is the default)
  export SPACK_CACHE="${SPACK_CACHE:-file://${CP2K_ROOT}/spack_cache}"

  # Prepare for package caching
  if [[ "${USE_CACHE}" == @("folder"|"minio") ]]; then
    # Create the venv only once, then reuse it on a resumed dependency build
    if [[ ! -x "${SPACK_BUILD_PATH}/venv/bin/python3" ]]; then
      if command -v python3 -m venv --help &> /dev/null; then
        echo "Installing virtual environment for Python packages"
        if ! python3 -m venv "${SPACK_BUILD_PATH}/venv"; then
          echo "ERROR: The creation of a virtual environment (venv) for Python packages failed"
          ${EXIT_CMD} 1
        fi
      else
        echo "ERROR: python3 -m venv was not found"
        ${EXIT_CMD} 1
      fi
    fi
    export PATH="${SPACK_BUILD_PATH}/venv/bin:${PATH}"

    # Avoid contacting PyPI again when the previously prepared venv is intact
    if ! python3 -c 'from importlib.metadata import version; assert version("boto3") == "1.38.11"; assert version("google-cloud-storage") == "3.1.0"' &> /dev/null; then
      if ! python3 -m pip --version &> /dev/null; then
        echo "ERROR: python3 -m pip was not found"
        ${EXIT_CMD} 1
      fi
      if ! retry_download python3 -m pip install "${VERBOSE_FLAG}" --upgrade pip \
        boto3==1.38.11 google-cloud-storage==3.1.0; then
        echo "ERROR: The installation of Python packages for the Spack cache failed"
        ${EXIT_CMD} 1
      fi
    fi
  fi

  # Prepare for using an MinIO object storage as cache
  if [[ "${USE_CACHE}" == "minio" ]]; then
    if [[ "${IN_CONTAINER}" == "yes" ]]; then
      echo "ERROR: An external MinIO object storage container cannot be used as cache within a container"
      echo "       Use \"folder\" or \"no\" caching instead of \"MinIO\""
      ${EXIT_CMD} 1
    fi
    # MinIO requires podman
    if command -v podman &> /dev/null; then
      # Check podman version
      ((VERBOSE > 0)) && podman version
      PODMAN_VERSION=$(podman version --format '{{.Client.Version}}' | awk -F'[.-]' '{print $1}')
      if ((PODMAN_VERSION < 4)); then
        echo "WARNING: Outdated podman version $(podman version --format '{{.Client.Version}}') found"
      fi
      export SPACK_CACHE="${SPACK_CACHE:-s3://spack-cache --s3-endpoint-url=http://localhost:9000}"
      if ! "${CP2K_ROOT}"/tools/docker/spack_cache_start.sh; then
        echo "ERROR: Could not start (new) spack cache"
        echo ""
        echo "An error message starting with \"Error: initial journal cursor: ...\" indicates that the"
        echo "journald logging does not work. Try to switch podman (3.x) to file-based logs by creating"
        echo "the file \"~/.config/containers/containers.conf\" with the following two lines:"
        echo "[containers]"
        echo "log_driver = \"k8s-file\""
        ${EXIT_CMD} 1
      fi
    else
      echo "INFO: podman was not found"
      echo "      Install the package podman to use an MinIO object storage as cache"
      echo "      This accelerates a rebuild of the CP2K dependencies, significantly"
      echo "      The folder ${SPACK_CACHE} will be used as cache"
      USE_CACHE="folder"
    fi
  fi

  # Initialize Spack shell hooks
  # shellcheck source=/dev/null
  source "${SPACK_ROOT}/share/spack/setup-env.sh"

  # Add spack cache as mirror if possible
  if [[ "${USE_CACHE}" == @("folder"|"minio") ]]; then
    echo "SPACK_CACHE = \"${SPACK_CACHE}\""
    spack mirror list
    if ! spack mirror list | grep -q "local-cache"; then
      echo "Setting up spack cache"
      if ((VERBOSE > 0)); then
        "${CP2K_ROOT}"/tools/docker/scripts/setup_spack_cache.sh
      else
        "${CP2K_ROOT}"/tools/docker/scripts/setup_spack_cache.sh &> /dev/null
      fi
    fi
  else
    echo "INFO: A spack cache is NOT used"
  fi

  # Prepare the CP2K spack configuration file
  CP2K_DEPS_FILE="${CP2K_ROOT}/tools/spack/cp2k_deps_${CP2K_VERSION:0:1}${CP2K_VERSION:4}.yaml"
  if [[ -f "${CP2K_DEPS_FILE}" ]]; then
    sed -E \
      -e "s|root: /opt/spack|root: ${SPACK_ROOT}/opt/spack|" \
      -e "/\"build_type=/s|build_type=[^\"]*|build_type=${DEPS_BUILD_TYPE}|" \
      "${CP2K_DEPS_FILE}" > "${CP2K_CONFIG_FILE}"
  else
    echo -e "\nERROR: The spack configuration file ${CP2K_DEPS_FILE} was not found\n"
    ${EXIT_CMD} 1
  fi

  # Apply selected MPI type if needed
  # MPICH is selected by default for psmp and no change needed for ssmp
  if [[ "${MPI_MODE}" == "openmpi" ]]; then
    sed -E \
      -e '/\s*-\s+"mpich@/ s/^ /#/' \
      -e '/\s*#\s*-\s+"openmpi@/ s/#/ /' \
      -e '/\s*-\s+mpich/ s/mpich$/openmpi/' \
      -i "${CP2K_CONFIG_FILE}"
  fi

  # Activate CUDA in the spack configuration file if requested
  if ((CUDA_SM_CODE > 0)); then
    # The generated MPI stack is not CUDA-aware, so COSMA has to stage MPI
    # transfers through host memory instead of passing device pointers.
    sed -E \
      -e "0,/~cuda/s//+cuda cuda_arch=${CUDA_SM_CODE}/" \
      -e 's/"~cuda\s+~gpu_direct"/"\+cuda ~gpu_direct"/' \
      -e '/\s*#\s*-\s+"fabrics=efa,ucx"/ s/#/ /' \
      -e "/^[[:space:]]+libxc:/{n; n; s/- \"~cuda\"/- \"+cuda cuda_arch=${CUDA_SM_CODE}\"/}" \
      -i "${CP2K_CONFIG_FILE}"
    # Building libfabric with CUDA causes problems
    # sed -E -e 's/"~cuda\s+~gdrcopy"/"\+cuda \+gdrcopy"/' -i "${CP2K_CONFIG_FILE}"
    sed -E -e 's/"~cuda\s+~gdrcopy"/"\~cuda"/' -i "${CP2K_CONFIG_FILE}"
    echo -e "\nLibxc will be built with CUDA support (cuda_arch=${CUDA_SM_CODE})"
    if [[ -n "${CUDA_VERSION:-}" ]]; then
      # Set CUDA SM code
      sed -E -e "s/spec:\s+cuda@[.0-9]*/spec: cuda@${CUDA_VERSION}/" -i "${CP2K_CONFIG_FILE}"
    fi
    if [[ -n "${CUDA_HOME:-}" ]]; then
      sed -E -e "s|prefix: /usr/local/cuda|prefix: ${CUDA_HOME}|" -i "${CP2K_CONFIG_FILE}"
    fi
  else
    sed -E \
      -e 's/"~cuda\s+~gdrcopy"/"\~cuda"/' \
      -e '/\s*-\s+"libgint@/ s/^ /#/' \
      -i "${CP2K_CONFIG_FILE}"
    # CUDA is required for LibGint
    export CMAKE_FEATURE_FLAGS="${CMAKE_FEATURE_FLAGS} -DCP2K_USE_LIBGINT=OFF"
    echo -e "\nLibGint requires CUDA support which is not enabled"
    echo -e "The CMAKE_FEATURE_FLAGS have been updated to disable LibGint\n"
  fi

  # Activate OpenCL support if requested
  if [[ "${USE_OPENCL}" == "yes" ]]; then
    sed -E \
      -e 's/"~opencl"/"+opencl"/' \
      -e '/\s*#\s*-\s+"libxstream@/ s/#/ /' \
      -i "${CP2K_CONFIG_FILE}"
  fi

  # Apply Cray specific adaptation of the spack configuration if requested (CSCS)
  if [[ "${CRAY}" == "yes" ]]; then
    sed -E \
      -e '/\s*#\s*-\s+"netmod=ofi"/ s/#/ /' \
      -e 's/~xpmem/+xpmem/' \
      -e 's/"libfabric@[.0-9]*"/"libfabric@1.22.0"/' \
      -i "${CP2K_CONFIG_FILE}"
  fi

  # Apply feature selection to spack configuration file
  if [[ -n "${SED_PATTERN_LIST}" ]]; then
    eval sed -E "${SED_PATTERN_LIST}" -i "${CP2K_CONFIG_FILE}"
  fi

  # Find all compilers
  echo "Searching for GCC compilers"
  if ! spack compiler find &> /dev/null; then
    echo "ERROR: The compiler detection of spack failed"
    ${EXIT_CMD} 1
  fi
  spack compiler list

  # Retrieve the newest compiler version found by spack
  GCC_VERSION_NEWEST="$(spack compilers | sed -nE 's/.*gcc@([0-9]+(\.[0-9]+)*).*/\1/p' | sort -V | tail -n 1)"
  echo "The newest GCC compiler version found by spack is ${GCC_VERSION_NEWEST}"
  GCC_VERSION_NEWEST="$(echo "${GCC_VERSION_NEWEST}" | sed -E -e 's/.*@([0-9]+).*/\1/' | cut -d. -f1)"

  # Check if the newest compiler version found on the host system is new enough
  GCC_VERSION_MINIMUM="10"
  if ((GCC_VERSION_NEWEST < GCC_VERSION_MINIMUM)); then
    echo "INFO: The newest GCC compiler version ${GCC_VERSION_NEWEST} is too old,"
    echo "      because at least version ${GCC_VERSION_MINIMUM} is required"
    GCC_VERSION="14"
    echo "INFO: The lastest stable GCC version ${GCC_VERSION} will be built and used by spack"
  fi

  # Add a specific GCC version to the spack configuration if requested
  if [[ "${GCC_VERSION}" == "auto" ]]; then
    echo "Spack will automatically select the GCC version which is not necessarily the newest one found"
  else
    sed -E -e "s/gcc@10:/gcc@${GCC_VERSION}/" -i "${CP2K_CONFIG_FILE}"
  fi

  # Create CP2K environment if needed
  if spack env list | grep -q "${CP2K_ENV}"; then
    echo "The Spack environment \"${CP2K_ENV}\" exists already"
  else
    cat "${CP2K_CONFIG_FILE}"
    echo "The Spack environment \"${CP2K_ENV}\" does NOT exist"
    if spack env create "${CP2K_ENV}" "${CP2K_CONFIG_FILE}" &> /dev/null; then
      echo "The Spack environment \"${CP2K_ENV}\" has been created"
    else
      echo "ERROR: The creation of the Spack environment \"${CP2K_ENV}\" failed"
      ${EXIT_CMD} 1
    fi
  fi

  # Activate CP2K environment if needed
  if spack env activate "${CP2K_ENV}" &> /dev/null; then
    echo "The Spack environment \"${CP2K_ENV}\" has been activated"
  else
    echo "ERROR: The activation of the Spack environment \"${CP2K_ENV}\" failed"
    ${EXIT_CMD} 1
  fi

  # Update the repo builtin
  if ! retry_download spack repo update; then
    echo "ERROR: The update of the repo builtin failed"
    ${EXIT_CMD} 1
  fi

  # CUDA-enabled libxc needs a C++ compiler, which the builtin recipe does not declare yet
  if ((CUDA_SM_CODE > 0)); then
    LIBXC_PACKAGE_FILE="$(find -L "${SPACK_USER_CACHE_PATH}/package_repos" -path "*/builtin/packages/libxc/package.py" -print -quit)"
    if [[ -f "${LIBXC_PACKAGE_FILE}" ]] && ! grep -q "type=\"build\", when=\"+cuda\"" "${LIBXC_PACKAGE_FILE}"; then
      sed -i \
        -e 's/^\(    depends_on("c", type="build")\)$/\1\n    depends_on("cxx", type="build", when="+cuda")/' \
        "${LIBXC_PACKAGE_FILE}"
      echo "The builtin spack recipe of libxc has been patched to add the cxx build dependency for CUDA builds"
    fi
  fi

  # Add the local CP2K development Spack repository when missing
  export CP2K_REPO="cp2k_dev"
  if ! spack repo list | grep -q "${CP2K_REPO}"; then
    spack repo add --scope "env:${CP2K_ENV}" "${CP2K_ROOT}/tools/spack/spack_repo/${CP2K_REPO}"
  else
    echo "The CP2K development repo ${CP2K_REPO} is already present ... skipping add"
  fi

  spack -e ${CP2K_ENV} repo list

  # Find all external packages
  if [[ "${USE_EXTERNALS}" == "yes" ]]; then
    if ! spack -C "${SPACK_USER_CONFIG_PATH}" external find; then
      echo -e "\nERROR: The detection of externals by spack failed"
      ${EXIT_CMD} 1
    fi
    # Concretize CP2K dependencies
    if ! spack -e "${CP2K_ENV}" concretize --fresh --jobs "${NUM_PROCS}"; then
      echo -e "\nERROR: The spack concretize for environment \"${CP2K_ENV}\" failed"
      echo ""
      echo "HINT: The (-ue | --use_externals) flags can cause conflicts with outdated"
      echo "      packages on the host system, e.g. old python or gcc versions"
      echo ""
      ${EXIT_CMD} 1
    fi
  else
    # If the installation of a specific GCC version for building CP2K is requested,
    # then an installation of the same GCC version on the host system has to be removed
    # from the configuration for a static build of CP2K
    if [[ "${CP2K_VERSION}" == *"-static" ]]; then
      if spack compilers | grep -q "gcc@${GCC_VERSION}"; then
        echo "INFO: A static build of CP2K with GCC ${GCC_VERSION} is requested without using"
        echo "      any externals which requires to build that GCC version with spack"
        echo "      while removing a gcc@${GCC_VERSION} installed on the host from the spack"
        echo "      configuration at the same time"
        if ! spack compiler remove "gcc@${GCC_VERSION}"; then
          echo -e "\nERROR: Removing the gcc@${GCC_VERSION} compiler failed"
          ${EXIT_CMD} 1
        else
          echo -e "\nINFO: gcc@${GCC_VERSION} compiler removed"
        fi
        spack compiler list
      fi
    fi
    if ! spack -e "${CP2K_ENV}" concretize --fresh --jobs "${NUM_PROCS}"; then
      echo -e "\nERROR: The spack concretize for environment \"${CP2K_ENV}\" failed"
      ${EXIT_CMD} 1
    fi
  fi

  ((VERBOSE > 0)) && spack find -c

  # Install CP2K dependencies via Spack (a retry skips already installed packages)
  if ! retry_download spack -e "${CP2K_ENV}" install -j "${NUM_PROCS}" -p "${NUM_PACKAGES}" "${VERBOSE_SPACK}"; then
    echo "ERROR: Building the CP2K dependencies with spack failed"
    if [[ "${USE_EXTERNALS}" == "yes" ]]; then
      echo "HINT:  Try to re-run the build without the (-ue | --use_externals) flag which avoids"
      echo "       errors or conflicts caused by externals from the host system"
    fi
    ${EXIT_CMD} 1
  fi

  # Find all compilers
  if ! spack compiler find; then
    echo "ERROR: The compiler detection of spack failed"
    ${EXIT_CMD} 1
  fi

  # Fix Libs list in elpa pkg-config file when CUDA is used
  if ((CUDA_SM_CODE > 0)); then
    ELPA_PKG_CONFIG_FILE="$(find -L "${SPACK_ROOT}/opt/spack/view" -name "elpa*.pc")"
    if [[ -f "${ELPA_PKG_CONFIG_FILE}" ]]; then
      sed -E -e 's|Libs: |Libs: -L/usr/local/cuda/lib64 |' -i "${ELPA_PKG_CONFIG_FILE}"
    fi
  fi

  # Return from spack folder after all installations are done
  cd "${CP2K_ROOT}" || ${EXIT_CMD} 1

  # Make a note of the successful build
  touch "${SPACK_BUILD_PATH}/BUILD_DEPENDENCIES_COMPLETED"

  echo -e "\n*** Installation of CP2K dependencies completed ***\n"

else

  # Initialize Spack shell hooks
  # shellcheck source=/dev/null
  source "${SPACK_ROOT}"/share/spack/setup-env.sh

fi

# Quit after (re)building all CP2K dependencies if requested
if [[ "${BUILD_DEPS_ONLY}" == "yes" ]]; then
  ${EXIT_CMD}
fi

### End of build CP2K dependencies ###

### Build CP2K ###

if spack env list | grep -q "${CP2K_ENV}"; then
  spack env list
else
  echo "ERROR: No Spack environment \"${CP2K_ENV}\" found"
  ${EXIT_CMD} 1
fi

# Activate spack environment
eval "$(spack env activate --sh ${CP2K_ENV})"

spack env status

# CMake configuration step
export CMAKE_BUILD_PATH="${BUILD_PATH}/build"

# PyTorch's TorchConfig.cmake is buried in the Python site-packages directory
Torch_DIR="$(dirname "$(find "${SPACK_ROOT}" ! -type l -name TorchConfig.cmake | tail -n 1)")"
export Torch_DIR

if [[ ! -d "${CMAKE_BUILD_PATH}" ]]; then
  mkdir -p "${CMAKE_BUILD_PATH}"
  case "${CP2K_VERSION}" in
    pdbg | psmp)
      # shellcheck disable=SC2086
      cmake -S "${CP2K_ROOT}" -B "${CMAKE_BUILD_PATH}" --preset "${CMAKE_PRESET}" \
        -GNinja \
        -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS} \
        -DCMAKE_BUILD_TYPE="${CP2K_BUILD_TYPE}" \
        -DCMAKE_Fortran_COMPILER_LAUNCHER="${Fortran_COMPILER_LAUNCHER}" \
        -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" \
        -DCMAKE_INSTALL_LIBDIR="lib" \
        -DCMAKE_INSTALL_MESSAGE="${INSTALL_MESSAGE}" \
        -DCMAKE_SKIP_RPATH="ON" \
        -DCMAKE_VERBOSE_MAKEFILE="${VERBOSE_MAKEFILE}" \
        ${CMAKE_FEATURE_FLAGS} \
        ${CMAKE_CUDA_FLAGS} \
        -Wno-error=dev |&
        tee "${CMAKE_BUILD_PATH}/cmake.log"
      EXIT_CODE=$?
      ;;
    sdbg | ssmp)
      # shellcheck disable=SC2086
      cmake -S "${CP2K_ROOT}" -B "${CMAKE_BUILD_PATH}" --preset "${CMAKE_PRESET}" \
        -GNinja \
        -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS} \
        -DCMAKE_BUILD_TYPE="${CP2K_BUILD_TYPE}" \
        -DCMAKE_Fortran_COMPILER_LAUNCHER="${Fortran_COMPILER_LAUNCHER}" \
        -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" \
        -DCMAKE_INSTALL_LIBDIR="lib" \
        -DCMAKE_INSTALL_MESSAGE="${INSTALL_MESSAGE}" \
        -DCMAKE_SKIP_RPATH="ON" \
        -DCMAKE_VERBOSE_MAKEFILE="${VERBOSE_MAKEFILE}" \
        ${CMAKE_FEATURE_FLAGS} \
        ${CMAKE_CUDA_FLAGS} \
        -Wno-error=dev |&
        tee "${CMAKE_BUILD_PATH}/cmake.log"
      EXIT_CODE=$?
      ;;
    ssmp-static)
      # Find some static libraries in advance
      LIBOPENBLAS=$(find -L "${SPACK_ROOT}"/opt/spack/view -name libopenblas.a)
      OPENBLAS_INCLUDE_DIR="$(
        dirname "$(find -L "${SPACK_ROOT}"/opt/spack/view -name cblas.h -print -quit)"
      )"
      LIBM="$(find /usr -name libm.a 2> /dev/null)"
      # shellcheck disable=SC2086
      cmake -S "${CP2K_ROOT}" -B "${CMAKE_BUILD_PATH}" --preset "${CMAKE_PRESET}" \
        -GNinja \
        -DBUILD_SHARED_LIBS="OFF" \
        -DCMAKE_BUILD_TYPE="${CP2K_BUILD_TYPE}" \
        -DCMAKE_EXE_LINKER_FLAGS="-static" \
        -DCMAKE_FIND_LIBRARY_SUFFIXES=".a" \
        -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" \
        -DCMAKE_INSTALL_LIBDIR="lib" \
        -DCMAKE_INSTALL_MESSAGE="${INSTALL_MESSAGE}" \
        -DCMAKE_SKIP_RPATH="ON" \
        -DCMAKE_VERBOSE_MAKEFILE="${VERBOSE_MAKEFILE}" \
        -DCP2K_BLAS_VENDOR="OpenBLAS" \
        -DCP2K_BLAS_INCLUDE_DIRS="${OPENBLAS_INCLUDE_DIR}" \
        -DCP2K_BLAS_LINK_LIBRARIES="${LIBOPENBLAS};${LIBM}" \
        -DCP2K_LAPACK_LINK_LIBRARIES="${LIBOPENBLAS};${LIBM}" \
        ${CMAKE_FEATURE_FLAGS} \
        -Wno-error=dev |&
        tee "${CMAKE_BUILD_PATH}/cmake.log"
      EXIT_CODE=$?
      # It is almost impossible to avoid that shared libraries are pulled in
      # when the CP2K dependencies are built and thus just change all shared
      # to static libraries hoping that these are also available
      sed -E -e "s/\.so/.a/g" -i build/build.ninja
      ;;
    *)
      echo "ERROR: Unknown CP2K version ${CP2K_VERSION} specified"
      ${EXIT_CMD} 1
      ;;
  esac
  if ((EXIT_CODE != 0)); then
    echo "ERROR: The CMake configuration step failed with the error code ${EXIT_CODE}"
    echo "       You can try to remove the build folder with 'rm -rf build' and re-run"
    echo "       or even start the whole CP2K installation from scratch with the \"-bd\" flag"
    ${EXIT_CMD} "${EXIT_CODE}"
  fi
fi

# CMake build step
echo -e "\n*** Compiling CP2K ***\n"
cmake --build "${CMAKE_BUILD_PATH}" --parallel "${NUM_PROCS}" -- "${VERBOSE_FLAG}" |& tee "${CMAKE_BUILD_PATH}"/ninja.log
EXIT_CODE=${PIPESTATUS[0]}
if ((EXIT_CODE != 0)); then
  echo "ERROR: The CMake build step failed with the error code ${EXIT_CODE}"
  ${EXIT_CMD} "${EXIT_CODE}"
fi

# CMake install step
echo -e "\n*** Installing CP2K ***\n"
cmake --install "${CMAKE_BUILD_PATH}" |& tee "${CMAKE_BUILD_PATH}"/install.log
EXIT_CODE=${PIPESTATUS[0]}
if ((EXIT_CODE != 0)); then
  echo -e "\nERROR: The CMake installation step failed with the error code ${EXIT_CODE}"
  ${EXIT_CMD} "${EXIT_CODE}"
fi

# Install Skala resource files if needed
export SKALA_MODEL="(not available)"
if spack location -i gauxc &> /dev/null; then
  GAUXC_PATH="share/gauxc/onedft_models"
  GAUXC_PREFIX="$(spack location -i gauxc)"
  GAUXC_MODEL_SOURCE_PATH="${GAUXC_PREFIX%/}/${GAUXC_PATH}"
  if [[ -d "${GAUXC_MODEL_SOURCE_PATH}" ]]; then
    GAUXC_MODEL_TARGET_PATH="${INSTALL_PREFIX%/}/${GAUXC_PATH}"
    mkdir -p "${GAUXC_MODEL_TARGET_PATH}"
    if compgen -G "${GAUXC_MODEL_SOURCE_PATH}/*.fun" > /dev/null; then
      cp "${GAUXC_MODEL_SOURCE_PATH}"/*.fun "${GAUXC_MODEL_TARGET_PATH}/"
    else
      echo -e "\nERROR: No GauXC model files found in source folder ${GAUXC_MODEL_SOURCE_PATH}"
      ${EXIT_CMD} 1
    fi
    shopt -s nullglob
    MATCHES=("${GAUXC_MODEL_TARGET_PATH}"/skala*)
    shopt -u nullglob
    if ((${#MATCHES[@]} > 0)); then
      export SKALA_MODEL="${MATCHES[${#MATCHES[@]} - 1]}"
    else
      echo -e "\nERROR: Failed to resolve SKALA_MODEL in target path ${GAUXC_MODEL_TARGET_PATH}"
      ${EXIT_CMD} 1
    fi
  fi
fi
echo -e "\nSKALA_MODEL = ${SKALA_MODEL}"

# Collect and compress all log files when building within a container
if [[ "${IN_CONTAINER}" == "yes" ]]; then
  if ! cat "${CMAKE_BUILD_PATH}"/cmake.log \
    "${CMAKE_BUILD_PATH}"/ninja.log \
    "${CMAKE_BUILD_PATH}"/install.log |
    gzip > "${CP2K_ROOT}"/build_cp2k.log.gz; then
    echo -e "\nERROR: The compressed log file generation failed"
    ${EXIT_CMD} 1
  fi
fi

# Cut extension from the CP2K version (e.g. ssmp-static -> ssmp)
export VERSION=${CP2K_VERSION%%-*}

# Add CP2K lib folder to the LD_LIBRARY_PATH
export LD_LIBRARY_PATH="${INSTALL_PREFIX}/lib:${LD_LIBRARY_PATH}"

# Assemble search paths for libraries
search_paths="${SPACK_ROOT}/opt/spack/view ${INSTALL_PREFIX}/lib"

# Retrieve paths to all libraries needed by the CP2k binary
for library in $(readelf -d "${INSTALL_PREFIX}/bin/cp2k.${VERSION}" "${INSTALL_PREFIX}"/lib/libcp2k.* | awk '/NEEDED/{print $5}' | tr -d '[]' | sort | uniq); do
  # Search for missing library path
  if ! ldconfig -p | grep -qE "/${library}$"; then
    # shellcheck disable=SC2086
    library_with_path=$(find -L ${search_paths} -name "${library}" | tail -n 1)
    if [[ -n "${library_with_path}" ]]; then
      library_path="$(dirname "${library_with_path}")"
      case ":${LD_LIBRARY_PATH}:" in
        *":${library_path}:"*)
          ((VERBOSE > 1)) && echo "The library path ${library_path} is already present ... skipping"
          ;;
        *)
          LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}${library_path}"
          ((VERBOSE > 0)) && echo "The library path ${library_path} was appended to LD_LIBRARY_PATH"
          ;;
      esac
    fi
  fi
done
export LD_LIBRARY_PATH
echo -e "\nLD_LIBRARY_PATH = \"${LD_LIBRARY_PATH}\""

# Create an ld configuration file for CP2K because LD_LIBRARY_PATH is fragile
if [[ "${IN_CONTAINER}" == "yes" ]]; then
  CP2K_LD_CONF_FILE="/etc/ld.so.conf.d/cp2k.conf"
else
  CP2K_LD_CONF_FILE="${INSTALL_PREFIX}/bin/cp2k.conf"
fi

# Either read LD_LIBRARY_PATH from an existing configuration file or write a new one
if [[ -f "${CP2K_LD_CONF_FILE}" ]]; then
  # Load LD_LIBRARY_PATH from an existing configuration file
  LD_LIBRARY_PATH="$(grep -E '^/' "${CP2K_LD_CONF_FILE}" | paste -sd ':' -)"
else
  # Write LD_LIBRARY_PATH to a new configuration file
  echo "${LD_LIBRARY_PATH}" | tr ':' '\n' | grep '^/' > "${CP2K_LD_CONF_FILE}"
fi

export LD_LIBRARY_PATH

# Create links to CP2K binaries
cd "${INSTALL_PREFIX}"/bin || ${EXIT_CMD} 1
for binary in *."${VERSION}"; do
  if ! ln -sf "${binary}" "${binary%%."${VERSION}"}"; then
    echo "ERROR: The creation of a symbolic link for the binary ${binary} failed"
    ${EXIT_CMD}
  fi
done
ln -sf cp2k."${VERSION}" cp2k_shell
cd "${CP2K_ROOT}" || ${EXIT_CMD} 1

# Configure Open MPI environment for local CP2K runs
if [[ "${MPI_MODE}" == "openmpi" ]]; then
  OMPI_VARS="export OMPI_MCA_plm_rsh_agent=/bin/false PRTE_MCA_hwloc_default_binding_policy=none"
  if [[ "${IN_CONTAINER}" == "yes" ]]; then
    OMPI_VARS="${OMPI_VARS} OMPI_ALLOW_RUN_AS_ROOT=1 OMPI_ALLOW_RUN_AS_ROOT_CONFIRM=1"
    OMPI_VARS="${OMPI_VARS} OMPI_MCA_mpi_yield_when_idle=1 OMPI_MCA_btl=self,sm OMPI_MCA_pml=ob1"
  fi
else
  OMPI_VARS=""
fi
export OMPI_VARS

# MPICH and OpenMPI have different flags for exporting environment variables to MPI ranks
if [[ "${MPI_MODE}" == "openmpi" ]]; then
  ENV_VAR_FLAG="-x"
else
  ENV_VAR_FLAG="-genv"
fi
export ENV_VAR_FLAG

# Install LSAN suppressions (only needed for dbg binaries)
cp "${CP2K_ROOT}"/tools/spack/lsan.supp "${INSTALL_PREFIX}"/bin

# Assemble flags for running the regression tests
TESTOPTS="--cp2kdatadir ${INSTALL_PREFIX}/share/cp2k/data  --maxtasks ${NUM_PROCS} --workbasedir ${INSTALL_PREFIX}/regtesting ${TESTOPTS}"
export TESTOPTS

# Create launch script for environment setup
LAUNCH_SCRIPT="${INSTALL_PREFIX}"/bin/launch
export LAUNCH_SCRIPT
cat << *** > "${LAUNCH_SCRIPT}"
#!/bin/bash
ulimit -c 0 -s unlimited
export ASAN_OPTIONS="detect_leaks=1"
export LSAN_OPTIONS="suppressions=${INSTALL_PREFIX}/bin/lsan.supp"
export PATH="${INSTALL_PREFIX}/bin:${INSTALL_PREFIX}/ase/bin:${PATH}"
export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"
export OMP_NUM_THREADS=\${OMP_NUM_THREADS:-2}
export OMP_STACKSIZE=256M
[[ -f ${INSTALL_PREFIX}/ase/config.ini ]] && export ASE_CONFIG_PATH="${INSTALL_PREFIX}/ase/config.ini"
[[ -f ${INSTALL_PREFIX}/bin/GMXRC ]] && source ${INSTALL_PREFIX}/bin/GMXRC
${OMPI_VARS}
export SKALA_MODEL=${SKALA_MODEL}
exec "\$@"
***
chmod 750 "${LAUNCH_SCRIPT}"

# Create shortcut for launching the CP2K regression tests
cat << *** > "${INSTALL_PREFIX}"/bin/run_tests
#!/bin/bash
if [[ "${VERSION}" =~ ^(s|p)dbg$ ]]; then
  echo "ASAN_OPTIONS = \${ASAN_OPTIONS}"
  echo "LSAN_OPTIONS = \${LSAN_OPTIONS}"
fi
ldd -- ${INSTALL_PREFIX}/bin/cp2k.${VERSION} 2>&1 | grep -E 'not ' | sort | uniq
export SKALA_MODEL=${SKALA_MODEL}
${CP2K_ROOT}/tests/do_regtest.py ${TESTOPTS} \$* ${INSTALL_PREFIX}/bin ${VERSION}
***
chmod 750 "${INSTALL_PREFIX}"/bin/run_tests

# Collect information from coding convention checks
if [[ "${CHECK_CONVENTIONS}" == "yes" ]]; then
  "${CP2K_ROOT}"/tools/conventions/analyze_gfortran_ast.py "${CMAKE_BUILD_PATH}"/*.ast --jobs "${NUM_PROCS}" \
    &> "${CMAKE_BUILD_PATH}"/ast.issues
  ((VERBOSE > 0)) && cat "${CMAKE_BUILD_PATH}"/ast.issues
  "${CP2K_ROOT}"/tools/conventions/analyze_gfortran_warnings.py "${CMAKE_BUILD_PATH}"/*.warn --jobs "${NUM_PROCS}" \
    &> "${CMAKE_BUILD_PATH}"/warn.issues
  ((VERBOSE > 0)) && cat "${CMAKE_BUILD_PATH}"/warn.issues
  "${CP2K_ROOT}"/tools/conventions/summarize_issues.py --suppressions="${CP2K_ROOT}/tools/conventions/conventions.supp" "${CMAKE_BUILD_PATH}"/*.issues
  cat << *** > "${INSTALL_PREFIX}"/bin/summarize_issues
#!/bin/bash
${CP2K_ROOT}/tools/conventions/summarize_issues.py --suppressions=${CP2K_ROOT}/tools/conventions/conventions.supp ${CMAKE_BUILD_PATH}/*.issues
***
  chmod 750 "${INSTALL_PREFIX}"/bin/summarize_issues
fi

# Create script to run the CP2K benchmarks for psmp builds
if [[ "${VERSION}" == "psmp" ]]; then
  if [[ "${IN_CONTAINER}" == "yes" ]]; then
    BENCHMARK_OUTPUT_DIR="/workspace/artifacts"
  else
    BENCHMARK_OUTPUT_DIR="${INSTALL_PREFIX}"/performance_tests
  fi
  cat << *** > "${INSTALL_PREFIX}"/bin/run_benchmarks
#!/bin/bash -e

BENCHMARK_PROFILE=\${1:-openmp}

MAX_PROCS=\$(nproc --all)
if ((MAX_PROCS < 32)); then
  echo -e "\nWARNING: 32 CPU cores are needed for a CP2K benchmark run but if seems only \${MAX_PROCS} are available"
fi

run_benchmark_input() {
  set +e
  local omp_threads="\$1"
  local mpi_ranks="\$2"
  local input="\$3"
  local output="\$4"
  printf "Running %s with %s threads and %s ranks... " \
    "\${input}" "\${omp_threads}" "\${mpi_ranks}"
  if OMP_NUM_THREADS="\${omp_threads}" mpiexec -n "\${mpi_ranks}" cp2k.psmp "\${input}" >"\${output}" 2>&1; then
    echo "done."
  else
    echo "failed."
    echo
    [[ -f "\${output}" ]] && tail -n 1000 "\${output}"
    echo
    echo "Summary: Running \${input} failed."
    echo "Status: FAILED"
    exit 0
  fi
  set -e
}

echo -e "\n========== Running Performance Test =========="
OUTPUT_DIR=${BENCHMARK_OUTPUT_DIR}
mkdir -p \${OUTPUT_DIR}
TIME_START=\$(date +%s)

BENCHMARKS=(
  "${CP2K_ROOT}/benchmarks/QS/H2O-64.inp"
  "${CP2K_ROOT}/benchmarks/QS/H2O-64_nonortho.inp"
  "${CP2K_ROOT}/benchmarks/QS_reference/w64PBE.inp"
  "${CP2K_ROOT}/benchmarks/QS_reference/w64GAPW-SVP.inp"
  "${CP2K_ROOT}/benchmarks/QS_reference/w64SCAN.inp"
  "${CP2K_ROOT}/benchmarks/QS_kp/ZnO.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/H2O-hyb.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/GW_PBE_4benzene.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/RI-HFX_H2O-32.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/RI-MP2_ammonia.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/diag_cu144_broy.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/bench_dftb.inp"
  "${CP2K_ROOT}/benchmarks/QS_single_node/dbcsr.inp"
  "${CP2K_ROOT}/benchmarks/QMMM/MQAE/MQAE_single_node.inp"
)

if [[ "\${BENCHMARK_PROFILE}" == "openmp" ]]; then
  echo 'Plot: name="total_timings_32omp", title="Total Timings with 32 OpenMP Threads", ylabel="time [s]"'
  echo 'Plot: name="total_timings_32mpi", title="Total Timings with 32 MPI Ranks", ylabel="time [s]"'
  echo ""

  for INPUT in "\${BENCHMARKS[@]}"; do
    INPUT_BASENAME=\$(basename "\${INPUT}")
    LABEL=\${INPUT_BASENAME%.*}
    OUTPUT_MPI="\${OUTPUT_DIR}/\${LABEL}_32mpi.out"
    OUTPUT_OMP="\${OUTPUT_DIR}/\${LABEL}_32omp.out"
    cd "\$(dirname "\${INPUT}")"
    run_benchmark_input 1 32 "\${INPUT_BASENAME}" "\${OUTPUT_MPI}"
    run_benchmark_input 32 1 "\${INPUT_BASENAME}" "\${OUTPUT_OMP}"
    cd ..
    echo ""
    ${CP2K_ROOT}/tools/docker/scripts/plot_performance.py \
      "\${LABEL} with 32 OpenMP Threads" "\${LABEL}" "32omp" "\${OUTPUT_OMP}" \
      "\${LABEL} with 32 MPI Ranks" "\${LABEL}" "32mpi" "\${OUTPUT_MPI}"
    echo ""
  done

else
  echo "ERROR: Unknown benchmark profile \${BENCHMARK_PROFILE} specified"
  exit 1
fi

TIME_END=\$(date +%s)
DURATION=\$(printf "%i" \$(((TIME_END - TIME_START) / 60)))

echo -e "\nSummary: Performance test took \${DURATION} minutes."
echo -e "Status: OK\n"
***
  chmod 750 "${INSTALL_PREFIX}"/bin/run_benchmarks
fi

# Set image tag if available
export IMAGE_TAG=${IMAGE_TAG:-<IMAGE ID>}

# Optionally, launch test run
if [[ "${RUN_TEST}" == "yes" ]]; then
  echo -e "\n*** Launching regression test run using the script ${INSTALL_PREFIX}/bin/run_tests\n"
  if [[ "${TEST_COVERAGE}" == "yes" ]]; then
    # Print only a warning when the regression test is failing and continue with coverage analysis
    if ! ${LAUNCH_SCRIPT} run_tests; then
      echo -e "\nWARNING: The regression test run failed, but the coverage analysis will still be performed\n"
    fi
  else
    ${LAUNCH_SCRIPT} run_tests
    EXIT_CODE=$?
    if ((EXIT_CODE != 0)); then
      echo -e "\nERROR: The regression test run failed with the error code ${EXIT_CODE}\n"
      ${EXIT_CMD} "${EXIT_CODE}"
    fi
  fi
else
  if [[ "${IN_CONTAINER}" == "yes" ]]; then
    if ((CUDA_SM_CODE > 0)); then
      DEVICE_FLAG=" --device nvidia.com/gpu=all"
    else
      DEVICE_FLAG=""
    fi
    echo ""
    echo "*** A regression test run can be launched with"
    echo "    podman run -it${DEVICE_FLAG} --rm ${IMAGE_TAG} run_tests"
    echo ""
    if [[ "${VERSION}" == @(sdbg|ssmp) ]]; then
      echo "*** A CP2K run using 2 OpenMP threads (default) can be launched with"
      echo "    podman run -it${DEVICE_FLAG} --rm ${IMAGE_TAG} cp2k ${CP2K_ROOT}/benchmarks/CI/H2O-32_md.inp"
    else
      echo "*** An MPI-parallel CP2K run using 2 OpenMP threads for each of the 4 MPI ranks can be launched with"
      echo "    podman run -it${DEVICE_FLAG} --rm ${IMAGE_TAG} mpiexec -n 4 ${ENV_VAR_FLAG} OMP_NUM_THREADS=2 cp2k ${CP2K_ROOT}/benchmarks/CI/H2O-32_md.inp"
    fi
  else
    echo ""
    echo "*** A regression test run can be launched with"
    echo "    ${LAUNCH_SCRIPT} run_tests"
    echo ""
    if [[ "${VERSION}" == @(sdbg|ssmp) ]]; then
      echo "*** A CP2K run using 2 OpenMP threads (default) can be launched with"
      echo "    ${LAUNCH_SCRIPT} cp2k ${CP2K_ROOT}/benchmarks/CI/H2O-32_md.inp"
      echo ""
      echo "*** A CP2K run using only 4 OpenMP threads can be launched with"
      echo "    export OMP_NUM_THREADS=4; ${LAUNCH_SCRIPT} cp2k ${CP2K_ROOT}/benchmarks/CI/H2O-32_md.inp"
    else
      echo "*** An MPI-parallel CP2K run using 2 OpenMP threads for each of the 4 MPI ranks can be launched with"
      echo "    export OMP_NUM_THREADS=2; ${LAUNCH_SCRIPT} mpiexec -n 4 cp2k ${CP2K_ROOT}/benchmarks/CI/H2O-32_md.inp"
    fi
  fi
fi

# Optionally, analyse code coverage and generate a coverage report
if [[ "${TEST_COVERAGE}" == "yes" ]]; then
  if [[ "${IN_CONTAINER}" == "yes" ]]; then
    COVERAGE_OUTPUT_DIR="/workspace/artifacts/coverage"
  else
    COVERAGE_OUTPUT_DIR="${INSTALL_PREFIX}"/coverage
  fi
  mkdir -p "${COVERAGE_OUTPUT_DIR}"
  COVERAGE_OUTPUT_FILE="${COVERAGE_OUTPUT_DIR}/coverage.info"
  lcov --directory "${CMAKE_BUILD_PATH}/src" \
    --exclude "${SPACK_BUILD_PATH}/*" \
    --exclude "/usr/*" \
    --capture \
    --keep-going \
    --output-file "${COVERAGE_OUTPUT_FILE}" &> "${COVERAGE_OUTPUT_DIR}"/lcov.log
  # Print coverage summary
  lcov --summary "${COVERAGE_OUTPUT_FILE}"
  genhtml --output-directory "${COVERAGE_OUTPUT_DIR}" --keep-going --title "CP2K Regtests (${CP2K_REVISION})" \
    "${COVERAGE_OUTPUT_FILE}" &> "${COVERAGE_OUTPUT_DIR}"/genhtml.log
  # Create plot data
  LINE_COV=$(lcov --summary "${COVERAGE_OUTPUT_FILE}" | grep lines | awk '{print substr($2, 1, length($2)-1)}')
  FUNC_COV=$(lcov --summary "${COVERAGE_OUTPUT_FILE}" | grep funct | awk '{print substr($2, 1, length($2)-1)}')
  echo 'Plot: name="cov", title="Test Coverage", ylabel="Coverage %"'
  echo "PlotPoint: name='lines', plot='cov', label='Lines', y=${LINE_COV}, yerr=0"
  echo "PlotPoint: name='funcs', plot='cov', label='Functions', y=${FUNC_COV}, yerr=0"
fi

# Optionally, run CP2K benchmark as performance check
if [[ "${VERSION}" == "psmp" ]]; then
  if [[ "${RUN_BENCHMARK}" == "yes" ]]; then
    echo -e "\n*** Launching benchmark run using the script ${INSTALL_PREFIX}/bin/run_benchmarks\n"
    ${LAUNCH_SCRIPT} run_benchmarks
    EXIT_CODE=$?
    if ((EXIT_CODE != 0)); then
      echo "ERROR: The benchmark run failed with the error code ${EXIT_CODE}"
      ${EXIT_CMD} "${EXIT_CODE}"
    fi
  else
    if [[ "${IN_CONTAINER}" != "yes" ]]; then
      echo ""
      echo "*** A benchmark run can be launched with"
      echo "    ${LAUNCH_SCRIPT} run_benchmarks"
      echo ""
    fi
  fi
fi

# Optionally, build GROMACS/CP2K
if [[ -n "${GROMACS_VERSION}" ]]; then

  # Download GROMACS
  GROMACS_ROOT="${CMAKE_BUILD_PATH}"/gromacs
  [[ -d "${GROMACS_ROOT}" ]] && rm -rf "${GROMACS_ROOT}"
  echo -e "\n*** Downloading GROMACS ${GROMACS_VERSION} ***\n"
  # Spack's OpenSSL libs on LD_LIBRARY_PATH can break the system git-remote-https
  # helper (mismatched libldap), so clone with a clean library path
  if ! LD_LIBRARY_PATH="" retry_download git clone -b "${GROMACS_VERSION}" -c advice.detachedHead=false --depth=1 ${VERBOSE_FLAG} --single-branch \
    https://gitlab.com/gromacs/gromacs.git "${GROMACS_ROOT}"; then
    echo -e "\nERROR: Downloading GROMACS ${GROMACS_VERSION} failed"
    ${EXIT_CMD} 1
  fi
  cd "${GROMACS_ROOT}" || ${EXIT_CMD} 1
  GROMACS_REVISION="$(git rev-parse --short HEAD)"

  # Retrieve the GROMACS major version from the source tree, since GROMACS_VERSION
  # is a branch or tag name (e.g. v2026.3, release-2026, main)
  GROMACS_VERSION_MAJOR=$(sed -n -E 's/^ *project\( *Gromacs +VERSION +([0-9]+).*/\1/p' CMakeLists.txt)
  if [[ ! ${GROMACS_VERSION_MAJOR} =~ ^[0-9]+$ ]]; then
    echo "ERROR: Could not determine the GROMACS major version from CMakeLists.txt"
    ${EXIT_CMD} 1
  fi
  echo "GROMACS major version: ${GROMACS_VERSION_MAJOR}"

  # CP2K requires MPI_THREAD_MULTIPLE when attaching to an already-initialized MPI environment.
  # GROMACS >= 2027 requests MPI_THREAD_MULTIPLE if the environment variable
  # GMX_USE_MPI_THREAD_MULTIPLE is set, whereas older versions always request
  # MPI_THREAD_FUNNELED and have to be patched
  if ((GROMACS_VERSION_MAJOR >= 2027)); then
    sed -i '/^exec "\$@"$/i export GMX_USE_MPI_THREAD_MULTIPLE=1' "${LAUNCH_SCRIPT}"
  else
    sed -E -e 's/MPI_Init_thread\(argc, argv, MPI_THREAD_FUNNELED,/MPI_Init_thread(argc, argv, MPI_THREAD_MULTIPLE,/' \
      -i src/gromacs/utility/init.cpp
  fi

  # CMake configuration step for GROMACS
  GROMACS_BUILD_PATH="${GROMACS_ROOT}"/build
  mkdir -p "${GROMACS_BUILD_PATH}"
  echo -e "\n*** Performing CMake configuration for GROMACS ${GROMACS_VERSION} ***\n"
  cmake -S "${GROMACS_ROOT}" -B "${GROMACS_BUILD_PATH}" \
    -DBUILD_SHARED_LIBS="OFF" \
    -DCMAKE_BUILD_TYPE="${CP2K_BUILD_TYPE}" \
    -DCMAKE_CXX_STANDARD="20" \
    -DCMAKE_INSTALL_LIBDIR="lib" \
    -DCMAKE_INSTALL_PREFIX="${INSTALL_PREFIX}" \
    -DCP2K_DIR="${INSTALL_PREFIX}"/lib \
    -DGMX_BUILD_OWN_FFTW="ON" \
    -DGMX_CP2K="ON" \
    -DGMX_DOUBLE="OFF" \
    -DGMX_INSTALL_NBLIB_API="OFF" \
    -DGMX_MPI="${USE_MPI}" \
    -DGMXAPI="OFF" \
    -Werror=dev \
    &> "${GROMACS_BUILD_PATH}/cmake.log"
  EXIT_CODE=$?
  if ((EXIT_CODE != 0)); then
    echo "ERROR: The CMake configuration step for GROMACS failed with the error code ${EXIT_CODE}"
    [[ "${IN_CONTAINER}" == "yes" ]] && mkdir -p /workspace/artifacts/ && cp "${GROMACS_BUILD_PATH}"/*.log /workspace/artifacts/
    tail -n 1000 "${GROMACS_BUILD_PATH}"/cmake.log
    echo -e "\nStatus: FAILED\n"
    ${EXIT_CMD} "${EXIT_CODE}"
  fi

  # CMake build step for GROMACS
  echo -e "\n*** Compiling GROMACS ${GROMACS_VERSION} ***\n"
  cmake --build "${GROMACS_BUILD_PATH}" --parallel "${NUM_PROCS}" --target all qmmm_applied_forces-test &> "${GROMACS_BUILD_PATH}"/make.log
  EXIT_CODE=${PIPESTATUS[0]}
  if ((EXIT_CODE != 0)); then
    echo "ERROR: The CMake build step for GROMACS failed with the error code ${EXIT_CODE}"
    [[ "${IN_CONTAINER}" == "yes" ]] && mkdir -p /workspace/artifacts/ && cp "${GROMACS_BUILD_PATH}"/*.log /workspace/artifacts/
    tail -n 1000 "${GROMACS_BUILD_PATH}"/make.log
    ${EXIT_CMD} "${EXIT_CODE}"
  fi

  # CMake install step for GROMACS
  echo -e "\n*** Installing GROMACS ***\n"
  cmake --install "${GROMACS_BUILD_PATH}" &> "${GROMACS_BUILD_PATH}"/install.log &&
    cp "${GROMACS_BUILD_PATH}"/bin/qmmm_applied_forces-test "${INSTALL_PREFIX}"/bin
  EXIT_CODE=${PIPESTATUS[0]}
  if ((EXIT_CODE != 0)); then
    [[ "${IN_CONTAINER}" == "yes" ]] && mkdir -p /workspace/artifacts/ && cp "${GROMACS_BUILD_PATH}"/*.log /workspace/artifacts/
    echo -e "\nERROR: The CMake installation step for GROMACS failed with the error code ${EXIT_CODE}"
    tail -n 1000 "${GROMACS_BUILD_PATH}"/install.log
    ${EXIT_CMD} "${EXIT_CODE}"
  fi

  # Suppress GROMACS quote and reminder messages
  export GMX_NO_QUOTES=1

  # Print instructions for testing GROMACS/CP2K
  echo ""
  echo "*** The GROMACS/CP2K installation can be tested with"
  if [[ "${IN_CONTAINER}" == "yes" ]]; then
    echo "    podman run -it --rm ${IMAGE_TAG} ${LAUNCH_SCRIPT} qmmm_applied_forces-test"
  else
    echo "    ${LAUNCH_SCRIPT} qmmm_applied_forces-test"
  fi
  echo ""

  # Test GROMACS/CP2K installation
  GROMACS_BINARY="gmx"
  [[ ${USE_MPI} == "ON" ]] && GROMACS_BINARY+="_mpi"
  if [[ "${TEST_GROMACS}" == "yes" ]]; then
    if ${LAUNCH_SCRIPT} ${GROMACS_BINARY} --version; then
      echo -e "\n*** Running GROMACS/CP2K QM/MM unit test ***\n"
      if ${LAUNCH_SCRIPT} qmmm_applied_forces-test; then
        echo -e "\nSummary: GROMACS commit ${GROMACS_REVISION} works fine"
        echo -e "Status: OK\n"
      else
        echo -e "\nSummary: Something is wrong with GROMACS commit ${GROMACS_REVISION}"
        echo -e "Status: FAILED\n"
        ${EXIT_CMD} 0
      fi
    else
      echo -e "\nSummary: Something is wrong with GROMACS commit ${GROMACS_REVISION}"
      echo -e "Status: FAILED\n"
      ${EXIT_CMD} 0
    fi
  fi

  # Print usage hint
  echo -e "\n*** See benchmarks/GROMACS/MQAE/README.md for how to run GROMACS/CP2K\n"

fi

# Optionally, build CP2K with ASE support
if [[ -n "${ASE_VERSION}" ]]; then

  # Download ASE
  ASE_ROOT="${CMAKE_BUILD_PATH}"/ase
  [[ -d "${ASE_ROOT}" ]] && rm -rf "${ASE_ROOT}"
  echo -e "\n*** Downloading ASE ${ASE_VERSION} ***\n"
  # Spack's OpenSSL libs on LD_LIBRARY_PATH can break the system git-remote-https
  # helper (mismatched libldap), so clone with a clean library path
  if ! LD_LIBRARY_PATH="" retry_download git clone -b "${ASE_VERSION}" -c advice.detachedHead=false --depth=1 ${VERBOSE_FLAG} --single-branch \
    https://gitlab.com/ase/ase.git "${ASE_ROOT}"; then
    echo -e "\nERROR: Downloading ASE ${ASE_VERSION} failed"
    ${EXIT_CMD} 1
  fi
  cd "${ASE_ROOT}" || ${EXIT_CMD} 1
  ASE_REVISION="$(git rev-parse --short HEAD)"

  # Install ASE
  echo -e "\n*** Installing ASE ${ASE_VERSION} ***\n"
  if ! python3 -m venv "${INSTALL_PREFIX}"/ase; then
    echo -e "\nERROR: The creation of the virtual environment for ASE failed"
    ${EXIT_CMD} 1
  fi
  export PATH="${INSTALL_PREFIX}/ase/bin:${PATH}"
  if ! retry_download "${INSTALL_PREFIX}"/ase/bin/python3 -m pip install --ignore-installed ${VERBOSE_FLAG} ".[test]"; then
    echo -e "\nERROR: The ASE installation (venv) failed"
    ${EXIT_CMD} 1
  fi
  cat << *** > "${INSTALL_PREFIX}"/ase/config.ini
[cp2k]
cp2k_shell = ${INSTALL_PREFIX}/bin/cp2k_shell
cp2k_main =  ${INSTALL_PREFIX}/bin/cp2k
***
  # Install additional packages for ASE
  if ! retry_download "${INSTALL_PREFIX}"/ase/bin/python3 -m pip install --ignore-installed ${VERBOSE_FLAG} matplotlib numpy packaging six spglib; then
    echo -e "\nERROR: The installation of additional packages for ASE failed"
    ${EXIT_CMD} 1
  fi
  echo ""
  echo "*** The ASE/CP2K installation can be tested with"
  if [[ "${IN_CONTAINER}" == "yes" ]]; then
    echo "    podman run -it --rm ${IMAGE_TAG} ${LAUNCH_SCRIPT} test_ase"
  else
    echo "    ${LAUNCH_SCRIPT} test_ase"
  fi
  echo ""

  # Test the ASE installation
  echo "${LAUNCH_SCRIPT} ase test -j 0 -c cp2k calculator/cp2k" > "${INSTALL_PREFIX}"/ase/bin/test_ase
  chmod 750 "${INSTALL_PREFIX}"/ase/bin/test_ase
  if [[ "${TEST_ASE}" == "yes" ]]; then
    echo -e "\n*** Running ASE tests ***\n"
    if [[ "${IN_CONTAINER}" == "yes" ]]; then
      export PYTEST_DEBUG_TEMPROOT="/workspace/artifacts"
      mkdir -p ${PYTEST_DEBUG_TEMPROOT}
    fi
    if "${INSTALL_PREFIX}"/ase/bin/test_ase; then
      echo -e "\nSummary: ASE commit ${ASE_REVISION} works fine"
      echo -e "Status: OK\n"
      ${EXIT_CMD} 0
    else
      echo -e "\nSummary: Something is wrong with ASE commit ${ASE_REVISION}"
      echo -e "Status: FAILED\n"
      ${EXIT_CMD} 0
    fi
  fi

fi