CollectBuildInfoVars.cmake

# =============================================================================
# This script is included to set all build information variables in the
# calling scope. It does not use a function to avoid variable scope issues.
# ==============================================================================

# --- 1. Collect Basic Build Information ---
get_property(_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(_multi_config)
  set(ABACUS_BUILD_TYPE "Multi-config (${CMAKE_CONFIGURATION_TYPES})")
elseif(CMAKE_BUILD_TYPE)
  set(ABACUS_BUILD_TYPE "${CMAKE_BUILD_TYPE}")
else()
  set(ABACUS_BUILD_TYPE "Default")
endif()
if(DEFINED ENV{USER})
    set(ABACUS_BUILD_USER "$ENV{USER}")
else()
    set(ABACUS_BUILD_USER "Unknown")
endif()
site_name(ABACUS_BUILD_HOST)
set(ABACUS_CXX_COMPILER_ID ${CMAKE_CXX_COMPILER_ID})
set(ABACUS_CXX_COMPILER_PATH ${CMAKE_CXX_COMPILER})
set(ABACUS_CXX_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION})
set(TEMP_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS}")
#if(DEFINED CMAKE_BUILD_TYPE)
#    string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPER)
#    list(APPEND TEMP_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
#endif()
string(REPLACE ";" " " ABACUS_CXX_FLAGS "${TEMP_CXX_FLAGS_LIST}")
set(TEMP_LINKER_FLAGS_LIST "${CMAKE_EXE_LINKER_FLAGS}")
#if(DEFINED CMAKE_BUILD_TYPE)
#    string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPER)
#    list(APPEND TEMP_LINKER_FLAGS_LIST "${CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
#endif()
string(REPLACE ";" " " ABACUS_LINKER_FLAGS "${TEMP_LINKER_FLAGS_LIST}")
set(TEMP_CUDA_FLAGS_LIST "${CMAKE_EXE_CUDA_FLAGS}")
string(REPLACE ";" " " ABACUS_CUDA_FLAGS "${TEMP_CUDA_FLAGS_LIST}")

# --- 2. Determine Target Platform ---
if(USE_DSP)
    set(ABACUS_PLATFORM_NAME "DSP")
elseif(USE_SW)
    set(ABACUS_PLATFORM_NAME "CPU + SW-MATH")
elseif(USE_CUDA_ON_DCU)
    set(ABACUS_PLATFORM_NAME "CPU + DCU (Hygon CUDA)")
elseif(USE_CUDA)
    set(ABACUS_PLATFORM_NAME "CPU + NVIDIA CUDA")
elseif(USE_ROCM)
    set(ABACUS_PLATFORM_NAME "CPU + AMD ROCm")
else()
    set(ABACUS_PLATFORM_NAME "CPU")
endif()

# --- 3. Sanitizers & Debugging ---
if(ENABLE_ASAN)
    set(ABACUS_ASAN_STATUS "yes")
else()
    set(ABACUS_ASAN_STATUS "no")
endif()
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    set(ABACUS_DEBUG_SYMBOLS "yes")
else()
    set(ABACUS_DEBUG_SYMBOLS "no")
endif()

# --- 4. Get Dependency Versions (Enhanced with path fallback) ---
# MPI Implementation and Version
set(ABACUS_MPI_IMPLEMENTATION "no")
set(ABACUS_MPI_VERSION "no")
set(ABACUS_CUDA_AWARE_MPI "no")
if(ENABLE_MPI)
    if("${MPI_CXX_LIBRARY_VERSION_STRING}" MATCHES "Intel")
        set(ABACUS_MPI_IMPLEMENTATION "Intel MPI")
    elseif("${MPI_CXX_LIBRARY_VERSION_STRING}" MATCHES "Open MPI")
        set(ABACUS_MPI_IMPLEMENTATION "OpenMPI")
    elseif("${MPI_CXX_LIBRARY_VERSION_STRING}" MATCHES "MPICH")
        set(ABACUS_MPI_IMPLEMENTATION "MPICH")
    else()
        set(ABACUS_MPI_IMPLEMENTATION "Unknown")
    endif()
    set(ABACUS_MPI_VERSION "(MPI standard: ${MPI_CXX_VERSION})")
    if(USE_CUDA)           
        # OpenMPI hint
        find_program(OMPI_INFO_EXECUTABLE ompi_info)
        if(OMPI_INFO_EXECUTABLE)
            execute_process(COMMAND ${OMPI_INFO_EXECUTABLE} --parsable --all OUTPUT_VARIABLE OMPI_INFO_OUT OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
            if(OMPI_INFO_OUT MATCHES "mpi_built_with_cuda_support:value:true")
                if(USE_CUDA_MPI)
                  set(ABACUS_CUDA_AWARE_MPI "yes")
                else()
                  set(ABACUS_CUDA_AWARE_MPI "no (available but not enabled)")
                endif()
            else()
                set(ABACUS_CUDA_AWARE_MPI "no (or undetectable)")
            endif()
        else()
            execute_process(COMMAND ${MPI_CXX_COMPILER} -showme:compile OUTPUT_VARIABLE MPI_COMPILE_FLAGS OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)        
            if(MPI_COMPILE_FLAGS MATCHES "cuda" OR MPI_COMPILE_FLAGS MATCHES "CUDA")     
                set(ABACUS_CUDA_AWARE_MPI "yes (likely)")
            else()
                set(ABACUS_CUDA_AWARE_MPI "no (or undetectable)")
            endif()
        endif()
    else()
        set(ABACUS_CUDA_AWARE_MPI "no (CUDA not enabled)")
    endif()
endif()

# OpenMP Version
if(ENABLE_OPENMP AND OpenMP_CXX_VERSION)
    set(ABACUS_OPENMP_VERSION "yes (v${OpenMP_CXX_VERSION})")
elseif(ENABLE_OPENMP)
    set(ABACUS_OPENMP_VERSION "yes (version unknown)")
else()
    set(ABACUS_OPENMP_VERSION "no")
endif()

if(ENABLE_LCAO)
  set(ABACUS_LCAO_ENABLED "True")
  if(ENABLE_FFT_TWO_CENTER)
    set(ABACUS_TWO_CENTER_FFT "Enabled")
  else()
    set(ABACUS_TWO_CENTER_FFT "Disabled")
  endif()
else()
  set(ABACUS_LCAO_ENABLED "False")
endif()

# Core Math Libraries
if(ENABLE_LCAO AND ENABLE_ELPA)
    set(ABACUS_ELPA_VERSION "yes (v${ELPA_VERSION})")
else()
    set(ABACUS_ELPA_VERSION "no")
endif()

# BLAS and FFTW libraries
if(MKL_FOUND)
  set(ABACUS_BLAS_VENDOR "MKL")
  set(ABACUS_FFTW_VERSION "Using MKL")
  set(ABACUS_MKL_SUPPORT "yes (version unknown)")
  find_path(MKL_VERSION_HEADER mkl_version.h PATHS ${MKL_INCLUDE} NO_DEFAULT_PATH)
  if(MKL_VERSION_HEADER)
    file(STRINGS "${MKL_VERSION_HEADER}" MKL_VERSION_LINE REGEX "^#define INTEL_MKL_VERSION [0-9]+")
    string(REGEX REPLACE "^#define INTEL_MKL_VERSION ([0-9]+)" "\\1" MKL_VER_NUM "${MKL_VERSION_LINE}")
    if(MKL_VER_NUM)
      math(EXPR MKL_MAJOR "${MKL_VER_NUM} / 10000")
      math(EXPR MKL_MINOR "(${MKL_VER_NUM} % 10000) / 100")
      math(EXPR MKL_PATCH "${MKL_VER_NUM} % 100")
      set(ABACUS_MKL_SUPPORT "yes (v${MKL_MAJOR}.${MKL_MINOR}.${MKL_PATCH})")
    endif()
  endif()
else()
  set(ABACUS_MKL_SUPPORT "no")
  if(USE_SW)
    set(ABACUS_BLAS_VENDOR "SW")
    set(ABACUS_FFTW_VERSION "Using SW")
  elseif(USE_KML)
    set(ABACUS_BLAS_VENDOR "KML")
    set(ABACUS_FFTW_VERSION "Using KML")
  else()
    set(ABACUS_BLAS_VENDOR "Generic BLAS")
    if(FFTW3_VERSION)
      set(ABACUS_FFTW_VERSION "yes (v${FFTW3_VERSION})")
    else()
      if(FFTW3_INCLUDE_DIR AND EXISTS "${FFTW3_INCLUDE_DIR}/fftw3.h")
        file(STRINGS "${FFTW3_INCLUDE_DIR}/fftw3.h" _fftw_ver_line
             REGEX "^#define[\t ]+FFTW_VERSION[\t ]+\"[^\"]+\"")
        if(_fftw_ver_line)
          string(REGEX REPLACE "^#define[\t ]+FFTW_VERSION[\t ]+\"([^\"]+)\"" "\\1"
                 FFTW3_VERSION "${_fftw_ver_line}")
          set(ABACUS_FFTW_VERSION "yes (v${FFTW3_VERSION})")
        else()
          set(ABACUS_FFTW_VERSION "yes (version unknown)")
        endif()
      else()
        set(ABACUS_FFTW_VERSION "yes (version unknown)")
      endif()
    endif()
  endif()
endif()

if(ENABLE_LIBXC AND Libxc_VERSION)
    set(ABACUS_LIBXC_VERSION "yes (v${Libxc_VERSION})")
elseif(ENABLE_LIBXC)
    set(ABACUS_LIBXC_VERSION "yes (path: ${Libxc_DIR})")
else()
    set(ABACUS_LIBXC_VERSION "no")
endif()

if(ENABLE_DFTD4)
    set(ABACUS_DFTD4_VERSION "yes (v${dftd4_VERSION})")
else()
    set(ABACUS_DFTD4_VERSION "no")
endif()

# Accelerators
if(USE_CUDA AND CUDAToolkit_VERSION)
    set(ABACUS_CUDA_VERSION "yes (v${CUDAToolkit_VERSION})")
elseif(USE_CUDA)
    set(ABACUS_CUDA_VERSION "yes (version unknown)")
else()
    set(ABACUS_CUDA_VERSION "no")
endif()

if(USE_ROCM)
    set(ABACUS_ROCM_VERSION "yes (version unknown)")
    if(HIP_VERSION)
    set(ABACUS_ROCM_VERSION "yes (v${HIP_VERSION})")
    else()
        find_program(HIPCC_EXECUTABLE hipcc)
        if(HIPCC_EXECUTABLE)
            execute_process(COMMAND ${HIPCC_EXECUTABLE} --version OUTPUT_VARIABLE HIPCC_VERSION_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
            string(REGEX MATCH "HIP version: ([0-9]+\\.[0-9]+\\.[0-9]+)" _ "${HIPCC_VERSION_OUTPUT}")
            if(CMAKE_MATCH_1)
    set(ABACUS_ROCM_VERSION "yes (v${CMAKE_MATCH_1})")
endif()
        endif()
    endif()
    if(ABACUS_ROCM_VERSION STREQUAL "yes (version unknown)" AND ROCM_PATH)
        set(ABACUS_ROCM_VERSION "yes (path: ${ROCM_PATH})")
    endif()
else()
    set(ABACUS_ROCM_VERSION "no")
endif()

if(DEFINED CAL_CUSOLVERMP_PATH AND ENABLE_CUSOLVERMP)
  set(ABACUS_CUSOLVERMP_VERSION "yes (path: ${CAL_CUSOLVERMP_PATH})")
elseif(ENABLE_CUSOLVERMP)
  set(ABACUS_CUSOLVERMP_VERSION "yes (version unknown)")
else()
  set(ABACUS_CUSOLVERMP_VERSION "no")
endif()

if(ENABLE_CUBLASMP)
  set(ABACUS_CUBLASMP_VERSION "yes")
else()
  set(ABACUS_CUBLASMP_VERSION "no")
endif()

if(ENABLE_NCCL_PARALLEL_DEVICE)
  set(ABACUS_NCCL_PARA "Enabled")
else()
  set(ABACUS_NCCL_PARA "Enabled")
endif()

# EXX Libraries
if(ENABLE_LIBRI)
    set(ABACUS_LIBRI_VERSION "yes (version unknown)")
    set(LIBRI_VERSION_HEADER "${LIBRI_DIR}/include/RI/version.h")
    if(EXISTS ${LIBRI_VERSION_HEADER})
        file(STRINGS "${LIBRI_VERSION_HEADER}" LIBRI_MAJOR_LINE REGEX "__LIBRI_VERSION_MAJOR")
        file(STRINGS "${LIBRI_VERSION_HEADER}" LIBRI_MINOR_LINE REGEX "__LIBRI_VERSION_MINOR")
        file(STRINGS "${LIBRI_VERSION_HEADER}" LIBRI_PATCH_LINE REGEX "__LIBRI_VERSION_PATCH")
        string(REGEX MATCH "([0-9]+)" LIBRI_MAJOR "${LIBRI_MAJOR_LINE}")
        string(REGEX MATCH "([0-9]+)" LIBRI_MINOR "${LIBRI_MINOR_LINE}")
        string(REGEX MATCH "([0-9]+)" LIBRI_PATCH "${LIBRI_PATCH_LINE}")
        if(LIBRI_MAJOR AND LIBRI_MINOR AND LIBRI_PATCH)
            set(ABACUS_LIBRI_VERSION "yes (v${LIBRI_MAJOR}.${LIBRI_MINOR}.${LIBRI_PATCH})")
        endif()
    endif()
    if(ABACUS_LIBRI_VERSION STREQUAL "yes (version unknown)" AND LIBRI_DIR)
        set(ABACUS_LIBRI_VERSION "yes (path: ${LIBRI_DIR})")
    endif()
else()
    set(ABACUS_LIBRI_VERSION "no")
endif()

# LibComm Version
if(ENABLE_LIBRI AND LIBCOMM_DIR)
  set(ABACUS_LIBCOMM_VERSION "yes (path: ${LIBCOMM_DIR})")
elseif(ENABLE_LIBRI)
  set(ABACUS_LIBCOMM_VERSION "yes (version unknown)")
else()
  set(ABACUS_LIBCOMM_VERSION "no")
endif()

# Cereal Version (Enhanced)
if(ENABLE_LIBRI)
    set(ABACUS_CEREAL_VERSION "yes (version unknown)")
    if(NOT CEREAL_INCLUDE_DIR)
        find_path(CEREAL_INCLUDE_DIR cereal/version.hpp)
    endif()
    if(CEREAL_INCLUDE_DIR AND EXISTS "${CEREAL_INCLUDE_DIR}/cereal/version.hpp")
        file(STRINGS "${CEREAL_INCLUDE_DIR}/cereal/version.hpp" CEREAL_MAJOR_LINE REGEX "^#define CEREAL_VERSION_MAJOR")
        file(STRINGS "${CEREAL_INCLUDE_DIR}/cereal/version.hpp" CEREAL_MINOR_LINE REGEX "^#define CEREAL_VERSION_MINOR")
        file(STRINGS "${CEREAL_INCLUDE_DIR}/cereal/version.hpp" CEREAL_PATCH_LINE REGEX "^#define CEREAL_VERSION_PATCH")
        string(REGEX REPLACE "^#define CEREAL_VERSION_MAJOR +([0-9]+).*" "\\1" CEREAL_MAJOR "${CEREAL_MAJOR_LINE}")
        string(REGEX REPLACE "^#define CEREAL_VERSION_MINOR +([0-9]+).*" "\\1" CEREAL_MINOR "${CEREAL_MINOR_LINE}")
        string(REGEX REPLACE "^#define CEREAL_VERSION_PATCH +([0-9]+).*" "\\1" CEREAL_PATCH "${CEREAL_PATCH_LINE}")
        if(CEREAL_MAJOR AND CEREAL_MINOR AND CEREAL_PATCH)
            set(ABACUS_CEREAL_VERSION "yes (v${CEREAL_MAJOR}.${CEREAL_MINOR}.${CEREAL_PATCH})")
        endif()
    endif()
    if(ABACUS_CEREAL_VERSION STREQUAL "yes (version unknown)" AND CEREAL_INCLUDE_DIR)
        set(ABACUS_CEREAL_VERSION "yes (path: ${CEREAL_INCLUDE_DIR})")
    endif()
else()
    set(ABACUS_CEREAL_VERSION "no")
endif()

# ML & AI Libraries
if(ENABLE_MLALGO)
  set(ABACUS_MLALGO "Enabled")
else()
  set(ABACUS_MLALGO "Disabled")
endif()

if((DEFINED Torch_DIR OR ENABLE_MLALGO) AND Torch_VERSION)
    set(ABACUS_LIBTORCH_VERSION "yes (v${Torch_VERSION})")
elseif(DEFINED Torch_DIR OR ENABLE_MLALGO)
    set(ABACUS_LIBTORCH_VERSION "yes (path: ${Torch_DIR})")
else()
    set(ABACUS_LIBTORCH_VERSION "no")
endif()

if(DEFINED DeePMD_DIR)
    set(ABACUS_DEEPMD_VERSION "yes (version unknown)")
    set(DEEPMD_VERSION_HEADER "${DeePMD_DIR}/include/deepmd/version.h")
    if(EXISTS ${DEEPMD_VERSION_HEADER})
        file(STRINGS "${DEEPMD_VERSION_HEADER}" DEEPMD_VERSION_LINE REGEX "global_install_prefix")
        if(DEEPMD_VERSION_LINE)
            string(REGEX MATCH "global_install_prefix=\".*deepmd-kit-([0-9]+\\.[0-9]+\\.[0-9]+)\"" _ "${DEEPMD_VERSION_LINE}")
            if(CMAKE_MATCH_1)
    set(ABACUS_DEEPMD_VERSION "yes (v${CMAKE_MATCH_1})")
endif()
        endif()
    endif()
    if(ABACUS_DEEPMD_VERSION STREQUAL "yes (version unknown)")
        set(ABACUS_DEEPMD_VERSION "yes (path: ${DeePMD_DIR})")
    endif()
else()
    set(ABACUS_DEEPMD_VERSION "no")
endif()

if(DEFINED NEP_DIR AND NEP_VERSION)
    set(ABACUS_NEP_VERSION "yes (v${NEP_VERSION})")
elseif(DEFINED NEP_DIR)
    set(ABACUS_NEP_VERSION "yes (path: ${NEP_DIR})")
else()
    set(ABACUS_NEP_VERSION "no")
endif()

if(DEFINED TensorFlow_DIR)
    set(ABACUS_TENSORFLOW_VERSION "yes (path: ${TensorFlow_DIR})")
else()
    set(ABACUS_TENSORFLOW_VERSION "no")
endif()

# Testing & Other Libraries
if(BUILD_TESTING)
    set(ABACUS_GTEST_VERSION "yes (from git origin/main)")
    set(ABACUS_TESTING "ON")
else()
    set(ABACUS_GTEST_VERSION "no")
    set(ABACUS_TESTING "OFF")
endif()

if(ENABLE_GOOGLEBENCH)
    set(ABACUS_GOOGLEBENCH_VERSION "Enabled")
else()
    set(ABACUS_GOOGLEBENCH_VERSION "Disabled")
endif()

if(DEFINED RapidJSON_DIR AND ENABLE_RAPIDJSON)
    set(ABACUS_RAPIDJSON_VERSION "yes (path: ${RapidJSON_DIR})")
elseif(ENABLE_RAPIDJSON)
    set(ABACUS_RAPIDJSON_VERSION "yes (from git origin/master)")
else()
    set(ABACUS_RAPIDJSON_VERSION "no")
endif()

if(ENABLE_MLALGO)
    set(ABACUS_LIBNPY_VERSION "yes (path: ${libnpy_SOURCE_DIR})")
else()
    set(ABACUS_LIBNPY_VERSION "no")
endif()

if(ENABLE_PEXSI)
    set(ABACUS_PEXSI_VERSION "yes (v${PEXSI_VERSION})")
else()
    set(ABACUS_PEXSI_VERSION "no")
endif()

if(ENABLE_CNPY)
    set(ABACUS_CNPY_VERSION "yes (path: ${cnpy_SOURCE_DIR})")
else()
    set(ABACUS_CNPY_VERSION "no")
endif()

# --- 5. Collect CMake Configuration Summary ---
set(ABACUS_CMAKE_OPTIONS "Build Options:")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_MPI=${ENABLE_MPI}")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_OPENMP=${ENABLE_OPENMP}")
list(APPEND CMAKE_OPTIONS_LIST "  USE_CUDA=${USE_CUDA}")
list(APPEND CMAKE_OPTIONS_LIST "  USE_ROCM=${USE_ROCM}")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_LCAO=${ENABLE_LCAO}")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_ELPA=${ENABLE_ELPA}")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_LIBXC=${ENABLE_LIBXC}")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_MLALGO=${ENABLE_MLALGO}")
list(APPEND CMAKE_OPTIONS_LIST "  ENABLE_ASAN=${ENABLE_ASAN}")
list(APPEND CMAKE_OPTIONS_LIST "  BUILD_TESTING=${BUILD_TESTING}")
foreach(option_line ${CMAKE_OPTIONS_LIST})
    set(ABACUS_CMAKE_OPTIONS "${ABACUS_CMAKE_OPTIONS}${option_line}")
endforeach()

set(ABACUS_CMAKE_FIND_PACKAGES "FindPackage Results:")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  MPI Found=${MPI_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  OpenMP Found=${OpenMP_CXX_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  CUDA Found=${CUDA_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  ROCm Found=${ROCM_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  ELPA Found=${ELPA_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  Libxc Found=${Libxc_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  PEXSI Found=${PEXSI_FOUND}")
list(APPEND CMAKE_FIND_PACKAGES_LIST "  LibRI Found=${LIBRI_FOUND}")
foreach(package_line ${CMAKE_FIND_PACKAGES_LIST})
    set(ABACUS_CMAKE_FIND_PACKAGES "${ABACUS_CMAKE_FIND_PACKAGES}${package_line}")
endforeach()

# ==============================================================================
# Print Build Summary
# ==============================================================================
message(" ===================================================================")
message("                       ABACUS Build Summary                         ")
message(" ===================================================================")
message(" Build Type        : ${ABACUS_BUILD_TYPE}")
message(" Platform          : ${ABACUS_PLATFORM_NAME}")
message(" Compiler          : ${ABACUS_CXX_COMPILER_ID} ${ABACUS_CXX_COMPILER_VERSION}")
message(" -------------------------------------------------------------------")
message(" MPI Support       : ${ABACUS_MPI_IMPLEMENTATION} ${ABACUS_MPI_VERSION}")
message(" CUDA-Aware MPI    : ${ABACUS_CUDA_AWARE_MPI}")
message(" OpenMP Support    : ${ABACUS_OPENMP_VERSION}")
message(" -------------------------------------------------------------------")
message(" LCAO Enabled      : ${ABACUS_LCAO_ENABLED}")
if(ENABLE_LCAO)
  message(" Two-center FFT    : ${ABACUS_TWO_CENTER_FFT}")
endif()
message(" -------------------------------------------------------------------")
message(" Math Libraries    : BLAS           = ${ABACUS_BLAS_VENDOR}")
message("                     FFTW           = ${ABACUS_FFTW_VERSION}")
message("                     ELPA           = ${ABACUS_ELPA_VERSION}")
if(ENABLE_ABACUS_LIBM)
  message("                     Internal libmath enabled")
endif()
message(" Accelerators      : CUDA           = ${ABACUS_CUDA_VERSION}")
if(USE_CUDA)
  message("                     cuSOLVERMp     = ${ABACUS_CUSOLVERMP_VERSION}")
  message("                     cuBLASMp       = ${ABACUS_CUBLASMP_VERSION}")
  message("                     NCCL parallel  = ${ABACUS_NCCL_PARA}")
endif()
message("                     HIP/ROCm       = ${ABACUS_ROCM_VERSION}")
message(" Machine Learning  : MLALGO         = ${ABACUS_MLALGO}")
message("                     Torch          = ${ABACUS_LIBTORCH_VERSION}")
message("                     DeePMD         = ${ABACUS_DEEPMD_VERSION}")
message("                     NEP            = ${ABACUS_NEP_VERSION}")
message(" Features          : Libxc          = ${ABACUS_LIBXC_VERSION}")
message("                     LibRI          = ${ABACUS_LIBRI_VERSION}")
if(ENABLE_EXX_DEV)
  message("                                      (EXX developing features enabled)")
endif()
message("                     DFT-D4         = ${ABACUS_DFTD4_VERSION}")
message("                     RAPIDJSON      = ${ABACUS_RAPIDJSON_VERSION}")
message("                     PEXSI          = ${ABACUS_PEXSI_VERSION}")
message("                     CNPY           = ${ABACUS_CNPY_VERSION}")
message(" -------------------------------------------------------------------")
message(" Build Testing     : ${ABACUS_TESTING}")
if(BUILD_TESTING)
  message(" GoogleBench       : ${ABACUS_GOOGLEBENCH_VERSION}")
endif()
message(" ===================================================================")