CMakeLists.txt

cmake_minimum_required(VERSION 3.16)

# Require out-of-source builds
file(TO_CMAKE_PATH "${CMAKE_BINARY_DIR}/CMakeLists.txt" LOC_PATH)
if(EXISTS "${LOC_PATH}")
  message(
    FATAL_ERROR
      "You cannot build in a source directory (or any directory with a CMakeLists.txt file). "
      "Please make a build subdirectory.")
endif()

include(CMakeDependentOption)
message(WARNING
  "The build system now uses cmake_dependent_option extensively.\n"
  "Many advanced options are now conditionally enabled based on their dependencies; "
  "when dependency conditions are not met, the corresponding options will be"
  "automatically turned OFF and hidden in cmake-gui/ccmake.\n"
  "Please review your configuration if you previously set these options manually."
)

if(POLICY CMP0135) # https://cmake.org/cmake/help/git-stage/policy/CMP0135.html
  cmake_policy(SET CMP0135 NEW)
  # Otherwise this policy generates a warning on CMake 3.24
endif()
if(POLICY CMP0144) # https://cmake.org/cmake/help/git-stage/policy/CMP0144.html
  cmake_policy(SET CMP0144 NEW)
endif()

project(
  ABACUS
  DESCRIPTION "ABACUS is an electronic structure package based on DFT."
  HOMEPAGE_URL "https://github.com/deepmodeling/abacus-develop"
  LANGUAGES CXX)

option(ENABLE_MPI "Enable MPI" ON)
option(ENABLE_OPENMP "Enable OpenMP" ON)
option(USE_CUDA "Enable CUDA" OFF)
cmake_dependent_option(ENABLE_GPU_NEIGHBOR_LIST
                       "Enable the CUDA GPU neighbor-list implementation"
                       OFF "USE_CUDA" OFF)
option(USE_ROCM "Enable ROCm" OFF)
option(USE_DSP "Enable DSP" OFF)
option(USE_CUDA_ON_DCU "Enable CUDA on DCU" OFF)
option(USE_KML "Enable Kunpeng Math Library" OFF)
option(USE_SW "Enable SW Architecture" OFF)

option(ENABLE_ABACUS_LIBM "Build libmath from source to speed up" OFF)
option(ENABLE_LIBXC "Enable using the LibXC package" OFF)
option(ENABLE_FLOAT_FFTW "Enable using single-precision FFTW library." OFF)

option(ENABLE_LCAO "Enable LCAO algorithm" ON)
option(ENABLE_DFTD4 "Enable DFT-D4 dispersion correction" OFF)

option(BUILD_TESTING "Build unittests" OFF)
option(DEBUG_INFO "Print message to debug" OFF)
option(ENABLE_ASAN "Enable AddressSanitizer" OFF)
option(MATH_INFO "Enable gathering math library information" OFF)
option(ENABLE_COVERAGE "Enable coverage build" OFF)
option(GIT_SUBMODULE "Check submodules during build" ON)

# Do not enable it if generated code will run on different CPUs
option(ENABLE_NATIVE_OPTIMIZATION
       "Enable compilation optimization for the native machine's CPU type" OFF)

option(COMMIT_INFO "Print commit information in log" ON)
option(ENABLE_GOOGLEBENCH "Enable GOOGLE-benchmark usage" OFF)
option(ENABLE_JSON "Enable JSON output" OFF)
option(ENABLE_CNPY "Enable cnpy usage" OFF)

# Options requiring MPI and LCAO
cmake_dependent_option(ENABLE_ELPA "Enable ELPA eigensolver" ON "ENABLE_MPI" OFF)
cmake_dependent_option(ENABLE_LIBRI "Enable LibRI for hybrid functional"
                       OFF "ENABLE_LCAO;ENABLE_MPI" OFF)
cmake_dependent_option(ENABLE_PEXSI "Enable PEXSI for LCAO" OFF "ENABLE_LCAO;ENABLE_MPI" OFF)
cmake_dependent_option(ENABLE_MLALGO "Enable the machine learning algorithms"
                       OFF "ENABLE_LCAO;ENABLE_MPI" OFF)

# EXX_DEV works with libRI PR#10 which is not merged into main branch; disabling it
# cmake_dependent_option(ENABLE_EXX_DEV "Enable LibRI developing features" OFF "ENABLE_LIBRI" OFF)

# Two-center FFT is only used in LCAO
cmake_dependent_option(ENABLE_FFT_TWO_CENTER "Enable FFT-based two-center integral method"
                       ON "ENABLE_LCAO" OFF)

# Benchmark requires BUILD_TESTING
cmake_dependent_option(ENABLE_GOOGLEBENCH "Enable GOOGLE-benchmark usage"
                       OFF "BUILD_TESTING" OFF)

# Options requiring CUDA
cmake_dependent_option(USE_CUDA_MPI "Enable CUDA-aware MPI" OFF "USE_CUDA;ENABLE_MPI" OFF)
cmake_dependent_option(ENABLE_CUSOLVERMP "Enable cuSOLVERMp"
                       OFF "USE_CUDA;ENABLE_MPI;ENABLE_LCAO" OFF)
cmake_dependent_option(ENABLE_CUBLASMP "Enable cuBLASMp" OFF "ENABLE_CUSOLVERMP" OFF)
cmake_dependent_option(ENABLE_NCCL_PARALLEL_DEVICE
                       "Enable NCCL-backed collectives in parallel_device; requires MPI"
                       OFF "USE_CUDA;ENABLE_MPI" OFF)

# ==============================================================================
# Deprecated options (TODO: Remove this section in the future release)
# ==============================================================================
function(abacus_rename_option old_name new_name)
  get_property(_old_defined CACHE "${old_name}" PROPERTY TYPE SET)
  if(NOT _old_defined)
    return()
  endif()
  message(DEPRECATION "${old_name} has been renamed to ${new_name}.")
  get_property(_type CACHE "${new_name}" PROPERTY TYPE)
  get_property(_help CACHE "${new_name}" PROPERTY HELPSTRING)
  set("${new_name}" "${${old_name}}" CACHE "${_type}" "${_help}" FORCE)
  unset("${old_name}" CACHE)
endfunction()
abacus_rename_option(USE_OPENMP ENABLE_OPENMP)
abacus_rename_option(USE_ABACUS_LIBM ENABLE_ABACUS_LIBM)
abacus_rename_option(INFO MATH_INFO)

if(DEFINED CACHE{ENABLE_RAPIDJSON})
  message(
    FATAL_ERROR
      "ENABLE_RAPIDJSON is no longer supported. "
      "ABACUS now uses nlohmann-json as its JSON backend; "
      "please use -DENABLE_JSON=ON instead.")
endif()

if(DEFINED CACHE{ENABLE_LIBCOMM})
  message(
    DEPRECATION
      "Option ENABLE_LIBCOMM is deprecated and will be ignored in a future release. "
      "LibComm is now treated as an implementation dependency of LibRI; "
      "please use -DENABLE_LIBRI=ON instead."
  )
  if(ENABLE_LIBCOMM AND NOT ENABLE_LIBRI)
    message(
      FATAL_ERROR
        "ENABLE_LIBCOMM was set, but LibComm is not a standalone ABACUS feature. "
        "Please use -DENABLE_LIBRI=ON instead."
    )
  endif()
  unset(ENABLE_LIBCOMM CACHE)
endif()
# ==============================================================================

# CTest defines BUILD_TESTING when it is first included. Include it only after
# ABACUS has declared its OFF-by-default option above.
include(CTest)

if(NOT DEFINED NVHPC_ROOT_DIR AND DEFINED ENV{NVHPC_ROOT})
  set(NVHPC_ROOT_DIR
      "$ENV{NVHPC_ROOT}"
      CACHE PATH "Path to NVIDIA HPC SDK root directory.")
endif()

# enable json support
if(ENABLE_JSON)
  find_package(nlohmann_json REQUIRED)
endif()

# get commit info
if(COMMIT_INFO)
  find_package(Git)
  if(NOT Git_FOUND)
    message(
      WARNING
        "Git is not found, and abacus will not output the git commit information in log.\n"
        "You can install Git first and reinstall abacus.")
  else()
    message(STATUS "Found git: attempting to get commit info...")
    execute_process(
      COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%h
      OUTPUT_VARIABLE GIT_COMMIT_HASH
      OUTPUT_STRIP_TRAILING_WHITESPACE
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
      RESULT_VARIABLE GIT_COMMIT_HASH_RESULT)
    execute_process(
      COMMAND ${GIT_EXECUTABLE} log -1 --format=%cd
      OUTPUT_VARIABLE GIT_COMMIT_DATE
      OUTPUT_STRIP_TRAILING_WHITESPACE
      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
      RESULT_VARIABLE GIT_COMMIT_DATE_RESULT)
    if(GIT_COMMIT_HASH_RESULT EQUAL 0 AND GIT_COMMIT_DATE_RESULT EQUAL 0)
      file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/commit.h"
           "#define COMMIT \"${GIT_COMMIT_HASH} (${GIT_COMMIT_DATE})\"\n")
      set(ABACUS_COMMIT_INFO_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}")
      message(STATUS "Current commit hash: ${GIT_COMMIT_HASH}")
      message(STATUS "Last commit date: ${GIT_COMMIT_DATE}")
    else()
      message(WARNING "Failed to get git commit info")
    endif()
  endif()
endif()

# Determine the ABACUS executable name.
if(NOT ENABLE_LCAO)
  set(_abacus_bin_level "pw")
# TODO: Not well-defined now.
elseif(ENABLE_LIBRI AND ENABLE_MLALGO)
  set(_abacus_bin_level "max")
elseif(ENABLE_LIBRI)
  set(_abacus_bin_level "std")
# TODO: Not well-defined now.
elseif(ENABLE_MLALGO)
  set(_abacus_bin_level "ml")
else()
  set(_abacus_bin_level "basic")
endif()

if(ENABLE_MPI)
  set(_abacus_bin_para "para")
elseif(ENABLE_OPENMP)
  set(_abacus_bin_para "omp")
else()
  set(_abacus_bin_para "ser")
endif()

if(USE_CUDA OR USE_ROCM)
  set(_abacus_bin_device "gpu")
elseif(USE_CUDA_ON_DCU)
  set(_abacus_bin_device "dcu")
elseif(USE_DSP)
  set(_abacus_bin_device "dsp")
elseif(USE_SW)
  set(_abacus_bin_device "sw")
endif()

# if(USE_KML)
#  set(_abacus_bin_device "kp")
# endif()

if(_abacus_bin_device)
  set(ABACUS_BIN_NAME "abacus_${_abacus_bin_level}_${_abacus_bin_device}")
else()
  set(ABACUS_BIN_NAME "abacus_${_abacus_bin_level}_${_abacus_bin_para}")
endif()

# Use DSP hardware
if(USE_DSP AND ENABLE_ELPA)
  message(FATAL_ERROR "USE_DSP is incompatible with ELPA.")
endif()

list(APPEND CMAKE_MODULE_PATH
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
     "${PROJECT_SOURCE_DIR}/cmake/modules")

if(ENABLE_COVERAGE)
  find_package(codecov)
  if(NOT codecov_FOUND)
    include(FetchContent)
    FetchContent_Declare(
      cmakecodecov
      GIT_REPOSITORY https://github.com/RWTH-HPC/CMake-codecov.git
      GIT_TAG master
      GIT_SHALLOW TRUE
      GIT_PROGRESS TRUE
    )
    FetchContent_Populate(cmakecodecov)
    list(APPEND CMAKE_MODULE_PATH ${cmakecodecov_SOURCE_DIR}/cmake)
    set(CMAKE_MODULE_PATH "${cmakecodecov_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
    find_package(codecov REQUIRED)
  endif()
endif()

set(ABACUS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/source)

if(NOT DEFINED CMAKE_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD 11)
endif()
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Enable languages required by optional dependencies
if(ENABLE_DFTD4 OR ENABLE_PEXSI)
  enable_language(C)
  enable_language(Fortran)
endif()

macro(set_if_higher VARIABLE VALUE)
  if(${VARIABLE} LESS ${VALUE})
    set(${VARIABLE} ${VALUE})
  endif()
endmacro()
if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
  message(WARNING "GCC4 is not fully supported.")
endif()
set(FETCHCONTENT_QUIET FALSE) # Notify user when cloning git repo

find_program(CCACHE ccache)
if(CCACHE)
  set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE} ${CMAKE_CXX_COMPILER_LAUNCHER})
  set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE} ${CMAKE_C_COMPILER_LAUNCHER})
  set(CMAKE_CUDA_COMPILER_LAUNCHER ${CCACHE} ${CMAKE_CUDA_COMPILER_LAUNCHER})
endif()

# Choose build type from: Debug Release RelWithDebInfo MinSizeRel
# Select 'Release' configuration for best performance; this will disable all
# assertions. Other default configurations are also available, see:
# https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#default-and-custom-configurations
# For default flags, see:
# https://github.com/Kitware/CMake/blob/master/Modules/Compiler/GNU.cmake#L55

if(ENABLE_COVERAGE)
  set(CMAKE_BUILD_TYPE "Debug")
endif()
if(ENABLE_ASAN)
  set(CMAKE_BUILD_TYPE "RelWithDebInfo")
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
  # Force turn off ENABLE_ABACUS_LIBM on Intel Compiler
  message(WARNING "ENABLE_ABACUS_LIBM is not available with Intel compilers; switching it off")
  set(ENABLE_ABACUS_LIBM OFF)
endif()

if(ENABLE_ELPA)
  find_package(ELPA REQUIRED)
endif()
if(ENABLE_PEXSI)
  find_package(PEXSI REQUIRED CONFIG)
  if(PEXSI_VERSION VERSION_LESS "2.0.0")
    message(FATAL_ERROR "PEXSI >= 2.0.0 is required; found version ${PEXSI_VERSION}")
  endif()
  set(CMAKE_CXX_STANDARD 14)
endif()

if(ENABLE_MPI)
  if(NOT CMAKE_CROSSCOMPILING)
    # FindMPI runs a probe executable to determine the MPI library version,
    # which FindMKL.cmake uses to auto-detect the BLACS interface.
    # When cross compiling, assume users know what they are doing.
    set(MPI_DETERMINE_LIBRARY_VERSION TRUE)
  endif()
  find_package(MPI COMPONENTS CXX REQUIRED)
endif()

if(USE_SW)
  set(SW ON)
endif()

find_package(Threads REQUIRED)

if(ENABLE_OPENMP)
  find_package(OpenMP REQUIRED)
endif()

if(DEFINED ENV{MKLROOT} AND NOT DEFINED MKLROOT)
  set(MKLROOT "$ENV{MKLROOT}")
endif()
if(USE_KML)
  set(_kml_components BLAS LAPACK FFTW3)
  if(ENABLE_MPI)
    list(APPEND _kml_components ScaLAPACK)
  endif()
  if(ENABLE_FLOAT_FFTW)
    list(APPEND _kml_components FFTW3_FLOAT)
  endif()

  find_package(KML REQUIRED COMPONENTS ${_kml_components})
elseif(MKLROOT OR MKL_ROOT)
  find_package(MKL REQUIRED)
elseif(NOT USE_SW)
  find_package(Lapack REQUIRED)
  # ScaLAPACK is a distributed-memory library and is only needed for the
  # MPI build. A serial build (e.g. the native Windows serial version)
  # must not require it.
  if(ENABLE_MPI)
    find_package(ScaLAPACK REQUIRED)
  endif()
  if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Intel|Clang")
    message(WARNING "Cannot determine the required Fortran runtime.")
  endif()
endif()

if(NOT USE_KML AND NOT MKL_FOUND AND NOT USE_SW)
  find_package(FFTW3 REQUIRED)
endif()

if(ENABLE_DFTD4)
  find_package(dftd4 REQUIRED)
  if(dftd4_VERSION VERSION_LESS "4.3.0")
    message(FATAL_ERROR "dftd4 >= 4.3.0 is required; found version ${dftd4_VERSION}")
  endif()
endif()

include(CheckLanguage)
check_language(CUDA)
if(CMAKE_CUDA_COMPILER)
  if(NOT DEFINED USE_CUDA)
    message(
      "CUDA components detected. \nWill build the CUDA version of ABACUS by default."
    )
    set(USE_CUDA ON)
  else()
    if(NOT USE_CUDA)
      message(
        STATUS
          "CUDA components detected, but USE_CUDA is set to OFF. NOT building CUDA version of ABACUS."
      )
    endif()
  endif()
else() # CUDA not found
  if(USE_CUDA)
    message(
      FATAL_ERROR
        "USE_CUDA is set but no CUDA components found.")
  endif()
endif()

if(USE_CUDA)
  cmake_minimum_required(VERSION 3.18) # required by `CUDA_ARCHITECTURES` below
  
  # Always find CUDAToolkit to get CUDAToolkit_VERSION
  find_package(CUDAToolkit REQUIRED)
  
  set_if_higher(CMAKE_CXX_STANDARD 14)
  if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL "13.0")
    message(STATUS "CUDA ${CUDAToolkit_VERSION} detected. Setting CMAKE_CUDA_STANDARD to 17.")
    set_if_higher(CMAKE_CXX_STANDARD 17)
  endif()
  set(CMAKE_CXX_EXTENSIONS ON)
  set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD})
  set(CMAKE_CUDA_STANDARD_REQUIRED ON)
  set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
  if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
    # check
    # https://gitlab.kitware.com/cmake/cmake/-/blob/master/Modules/Internal/CMakeCUDAArchitecturesAll.cmake
    # for available architectures in different CUDA versions
    
    # CUDA 13.0+ dropped support for architectures below 75
    if(CUDAToolkit_VERSION VERSION_LESS "13.0")
      set(CMAKE_CUDA_ARCHITECTURES
          60 # P100
          70 # V100
      )
    else()
      # Start with empty list; architectures 75+ will be added below
      set(CMAKE_CUDA_ARCHITECTURES)
    endif()
    
    # Add your CUDA arch here Check the Compute Capability version of your
    # GPU at: https://en.wikipedia.org/wiki/CUDA#GPUs_supported
    
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL 10.0)
      list(APPEND CMAKE_CUDA_ARCHITECTURES 75) # T4
    endif()
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL 11.0)
      list(APPEND CMAKE_CUDA_ARCHITECTURES 80) # A100
    endif()
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL 11.1)
      list(APPEND CMAKE_CUDA_ARCHITECTURES 86)
    endif()
    if(CUDAToolkit_VERSION VERSION_GREATER_EQUAL 11.8)
      list(APPEND CMAKE_CUDA_ARCHITECTURES 89 90)
    endif()
  endif()
  enable_language(CUDA)
  if(USE_CUDA)
    if (ENABLE_NCCL_PARALLEL_DEVICE)
      include(cmake/modules/SetupNccl.cmake)
      abacus_setup_nccl()
    endif()
    if (ENABLE_CUSOLVERMP)
      # Keep cuSOLVERMp discovery/linking logic in a dedicated module.
      include(cmake/modules/SetupCuSolverMp.cmake)
      abacus_setup_cusolvermp()
    endif()
    if (ENABLE_CUBLASMP)
      # Enforcement 1: cuBLASMp requires cuSOLVERMp to be enabled
      if (NOT ENABLE_CUSOLVERMP)
        message(FATAL_ERROR 
          "ENABLE_CUBLASMP is set to ON, but ENABLE_CUSOLVERMP is OFF."
          "In ABACUS, cuBLASMp support requires cuSOLVERMp to be enabled simultaneously."
          "Please set -DENABLE_CUSOLVERMP=ON.")
      endif()
      # Enforcement 2: cuBLASMp 0.8.0+ is incompatible with CAL backend
      # Note: _use_cal is defined inside abacus_setup_cusolvermp
      if (_use_cal)
        message(FATAL_ERROR 
          "cuBLASMp 0.8.0+ requires NCCL Symmetric Memory, but cuSOLVERMp is using CAL backend."
          "Please upgrade cuSOLVERMp to >= 0.7.0 to use NCCL for both.")
      endif()
      include(cmake/modules/SetupCuBlasMp.cmake)
      abacus_setup_cublasmp()
    endif()
  endif()
endif()

# Warning: CMake add support to HIP in version 3.21. This is rather a new
# version. Use cmake with AMD-ROCm:
# https://rocmdocs.amd.com/en/latest/Installation_Guide/Using-CMake-with-AMD-ROCm.html
if(USE_ROCM)
  message(
    DEPRECATION
    "Option USE_ROCM is deprecated and will be ignored in a future release. ")
  cmake_minimum_required(VERSION 3.18)
  if(NOT DEFINED ROCM_PATH)
    set(ROCM_PATH
        "/opt/rocm"
        CACHE STRING "Default ROCM installation directory.")
  endif()
  if(NOT DEFINED HIP_PATH)
    if(NOT DEFINED ENV{HIP_PATH})
      set(HIP_PATH
          "${ROCM_PATH}/hip"
          CACHE PATH "Path to which HIP has been installed")
    else()
      set(HIP_PATH
          $ENV{HIP_PATH}
          CACHE PATH "Path to which HIP has been installed")
    endif()
  endif()
  set(CMAKE_MODULE_PATH "${HIP_PATH}/cmake" ${CMAKE_MODULE_PATH})
  set(HIP_HIPCC_FLAGS -fno-gpu-rdc; --std=c++14) # --amdgpu-target=gfx906

  # find_package(ROCM REQUIRED)
  find_package(HIP REQUIRED)
  find_package(hipfft REQUIRED)
  find_package(hipblas REQUIRED)
  find_package(hipsolver REQUIRED)

  if(HIP_FOUND)
    message(STATUS "Found HIP: " ${HIP_VERSION})
  else()
    message(
      FATAL_ERROR
        "Could not find HIP. Ensure that HIP is either installed in ${ROCM_PATH}/hip or the variable HIP_PATH is set to point to the right location."
    )
  endif()

endif()

if(ENABLE_ASAN)
  if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
    message(
      FATAL_ERROR
        "Address Sanitizer is not supported on Intel Classic compiler. Use Intel oneAPI compiler (icpx) instead."
    )
  endif()
  add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
  add_link_options(-fsanitize=address)
endif()

if(ENABLE_MLALGO)
  find_path(libnpy_SOURCE_DIR npy.hpp HINTS ${libnpy_INCLUDE_DIR})
  if(NOT libnpy_SOURCE_DIR)
    include(FetchContent)
    FetchContent_Declare(
      libnpy
      GIT_REPOSITORY https://github.com/llohse/libnpy.git
      GIT_SHALLOW TRUE
      GIT_PROGRESS TRUE)
    FetchContent_MakeAvailable(libnpy)
  else()
  endif()
endif()

# Torch uses outdated components to detect CUDA arch, causing failure on
# latest CUDA kits. Set CMake variable TORCH_CUDA_ARCH_LIST in the form of
# "major.minor" if required.
if(ENABLE_MLALGO OR DEFINED Torch_DIR)
  find_package(Torch REQUIRED)
  if(NOT Torch_VERSION VERSION_LESS "2.1.0")
    set_if_higher(CMAKE_CXX_STANDARD 17)
  elseif(NOT Torch_VERSION VERSION_LESS "1.5.0")
    set_if_higher(CMAKE_CXX_STANDARD 14)
  endif()
  set(ABACUS_TORCH_CXX_FLAGS "${TORCH_CXX_FLAGS}")
endif()

if (ENABLE_CNPY)
  find_path(cnpy_SOURCE_DIR
    cnpy.h
    HINTS ${libnpy_INCLUDE_DIR}
  )
  if(NOT cnpy_SOURCE_DIR)
    include(FetchContent)
    FetchContent_Declare(
      cnpy
      GIT_REPOSITORY https://github.com/rogersce/cnpy.git
      GIT_PROGRESS TRUE
    )
    FetchContent_MakeAvailable(cnpy)
  else()
  endif()

  # find ZLIB and link
  find_package(ZLIB REQUIRED)
endif()

function(git_submodule_update)
  if(GIT_SUBMOD_RESULT EQUAL "0")
    message(DEBUG "Submodule init'ed")
  else()
    find_package(Git REQUIRED)
    if(NOT EXISTS "${PROJECT_SOURCE_DIR}/.git")
      message(FATAL_ERROR "Not a git repository; cannot update submodules")
    endif()

    message(STATUS "Updating submodules")
    execute_process(
      COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
      RESULT_VARIABLE GIT_SUBMOD_RESULT)
    if(NOT GIT_SUBMOD_RESULT EQUAL "0")
      message(
        FATAL_ERROR
          "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}."
      )
    endif()
  endif()
endfunction()

if(ENABLE_LIBRI)
  set_if_higher(CMAKE_CXX_STANDARD 14)
  find_package(LibRI REQUIRED)
  find_package(LibComm REQUIRED)
  find_package(cereal REQUIRED CONFIG)
endif()

if(ENABLE_LIBXC)
  find_package(Libxc CONFIG REQUIRED)
  if(Libxc_VERSION VERSION_LESS "5.1.7")
    message(FATAL_ERROR "Libxc >= 5.1.7 is required; found version ${Libxc_VERSION}")
  endif()
endif()

if(DEFINED DeePMD_DIR)
  find_package(DeePMD REQUIRED)
endif()

if(DEFINED NEP_DIR)
  find_package(NEP REQUIRED)
endif()

if(DEFINED TensorFlow_DIR)
  find_package(TensorFlow REQUIRED)
endif()

if(MATH_INFO)
  message(STATUS "Will gather math lib info.")
  # modifications on blas_connector and lapack_connector
endif()

# Target construction, final link ordering, installation, and test targets are
# intentionally centralized in source/CMakeLists.txt.
add_subdirectory(source)