Add Math::BLAS_LAPACK/FFTW/scalar_vector_functions.

CMake/CheckSincos.cmake

@@ -1,21 +1,6 @@
 INCLUDE(${CMAKE_ROOT}/Modules/CheckCXXSourceCompiles.cmake)
 
-SET(SINCOS_INCLUDE cmath)
-
-SET(ENABLE_MASS FALSE CACHE BOOL "ENABLE MASS math libraries for Power architecture")
-# This needs to go before HAVE_SINCOS
-IF(ENABLE_MASS)
-  INCLUDE(CMake/FindIBMMASS.cmake)
-  IF(HAVE_MASS)
-    SET(CMAKE_REQUIRED_INCLUDES ${MASS_INCLUDE_DIRECTORIES} ${CMAKE_REQUIRED_INCLUDES})
-    SET(CMAKE_REQUIRED_LINK_OPTIONS ${MASS_LINKER_FLAGS})
-    SET(CMAKE_REQUIRED_LIBRARIES ${MASS_LIBRARIES})
-  ENDIF(HAVE_MASS)
-ENDIF(ENABLE_MASS)
-
-MESSAGE("CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}")
-MESSAGE("CMAKE_REQUIRED_LINK_OPTIONS: ${CMAKE_REQUIRED_LINK_OPTIONS}")
-MESSAGE("CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}")
+SET(CMAKE_REQUIRED_LIBRARIES Math::scalar_vector_functions)
 
 SET( SINCOS_TEST_SRC
   "#include \"${SINCOS_INCLUDE}\"

CMake/FindFFTW.cmake

@@ -20,6 +20,11 @@ IF(FFTW_INCLUDE_DIR AND FFTW_LIBRARIES)
   MESSAGE(STATUS "FFTW_INCLUDE_DIR=${FFTW_INCLUDE_DIR}")
   MESSAGE(STATUS "FFTW_LIBRARIES=${FFTW_LIBRARIES}")
   SET(FFTW_FOUND TRUE)
+  #create FFTW3 target
+  ADD_LIBRARY(Math::FFTW3 INTERFACE IMPORTED)
+  SET_TARGET_PROPERTIES(Math::FFTW3 PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIR}"
+                                               INTERFACE_COMPILE_DEFINITIONS "HAVE_LIBFFTW"
+                                               INTERFACE_LINK_LIBRARIES "${FFTW_LIBRARIES}")
 ENDIF()
 
 MARK_AS_ADVANCED(

CMake/FindIBMMASS.cmake

@@ -7,9 +7,9 @@ set(SUFFIXES include)
 find_path(MASS_INCLUDE_DIRECTORIES name "mass.h" HINTS ${MASS_ROOT}
   PATH_SUFFIXES ${SUFFIXES})
 if (NOT MASS_INCLUDE_DIRECTORIES)
-  message(FATAL_ERROR "MASS_INCLUDE_DIRECTORIES not set. \"mass.h\" not found in MASS_ROOT/(${SUFFIXES})")
+  MESSAGE(FATAL_ERROR "MASS_INCLUDE_DIRECTORIES not set. \"mass.h\" not found in MASS_ROOT/(${SUFFIXES})")
 endif (NOT MASS_INCLUDE_DIRECTORIES)
-message("MASS_INCLUDE_DIRECTORIES: ${MASS_INCLUDE_DIRECTORIES}")
+MESSAGE(STATUS "MASS_INCLUDE_DIRECTORIES: ${MASS_INCLUDE_DIRECTORIES}")
 
   # Finding and setting the MASS_LINK_DIRECTORIES
   # the directory organization varies with platform and targets
@@ -19,10 +19,10 @@ set(SUFFIXES lib lib64)
 find_path(MASS_LINK_DIRECTORIES name "${MASS_FIND_LIB}" HINTS ${MASS_ROOT}
   PATH_SUFFIXES ${SUFFIXES})
 if (NOT MASS_LINK_DIRECTORIES)
-  message(FATAL_ERROR "MASS_LINK_DIRECTORIES not set. ${MASS_FIND_LIB} "
+  MESSAGE(FATAL_ERROR "MASS_LINK_DIRECTORIES not set. ${MASS_FIND_LIB} "
     "not found in MASS_ROOT/(${SUFFIXES})")
 endif (NOT MASS_LINK_DIRECTORIES)
-message("MASS_LINK_DIRECTORIES: ${MASS_LINK_DIRECTORIES}")
+MESSAGE(STATUS "MASS_LINK_DIRECTORIES: ${MASS_LINK_DIRECTORIES}")
 
 set(MASS_LINKER_FLAGS -L${MASS_LINK_DIRECTORIES} -Wl,-rpath,${MASS_LINK_DIRECTORIES})
 set(MASS_LIBRARIES "-lmass -lmassv")
@@ -45,6 +45,7 @@ for( int i = 0; i < in_size; ++i)
 vlog10(resultv, inputv, &in_size);
 }
 ")
+
 try_compile(HAVE_MASS ${CMAKE_BINARY_DIR}
   ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src_mass.cxx
   CMAKE_FLAGS
@@ -58,17 +59,17 @@ if ( NOT HAVE_MASS )
 endif ( NOT HAVE_MASS )
 
 IF ( HAVE_MASS )
-  SET( MASS_FOUND 1 )
-  SET( MASS_FLAGS ${MASS_COMPILE_DEFINITIONS} )
-  include_directories( ${MASS_INCLUDE_DIRECTORIES} )
-  set( HAVE_VECTOR_MATH 1 )
-  set( HAVE_MASSV 1 )
-  set( SINCOS_INCLUDE mass.h )
+  SET( MASS_FOUND TRUE )
+  SET( HAVE_MASSV TRUE )
   MESSAGE(STATUS "MASS found: HAVE_MASS=${HAVE_MASS}, HAVE_MASSV=${HAVE_MASSV}")
+
+  #create scalar_vector_functions target
+  ADD_LIBRARY(Math::scalar_vector_functions INTERFACE IMPORTED)
+  SET_TARGET_PROPERTIES(Math::scalar_vector_functions PROPERTIES INTERFACE_COMPILE_DEFINITIONS "HAVE_MASS;HAVE_MASSV"
+                                                                 INTERFACE_INCLUDE_DIRECTORIES "${MASS_INCLUDE_DIRECTORIES}"
+                                                                 INTERFACE_LINK_LIBRARIES "${MASS_LINKER_FLAGS} ${MASS_LIBRARIES}")
+  set( SINCOS_INCLUDE mass.h )
 ELSE( HAVE_MASS )
-  SET( MASS_FOUND 0 )
-  SET( MASS_FLAGS )
-  SET( MASS_LIBRARIES )
-  SET( MASS_LINKER_FLAGS )
-  MESSAGE("MASS not found")
+  SET( MASS_FOUND FALSE )
+  MESSAGE(STATUS "MASS not found")
 ENDIF( HAVE_MASS )

CMake/FindMKL.cmake

@@ -20,21 +20,21 @@ else (NOT MKL_ROOT)
   find_path(MKL_INCLUDE_DIRECTORIES "mkl.h" HINTS ${MKL_ROOT}
     PATH_SUFFIXES ${SUFFIXES})
   if (NOT MKL_INCLUDE_DIRECTORIES)
-    message(FATAL_ERROR "MKL_INCLUDE_DIRECTORIES not set. \"mkl.h\" not found in MKL_ROOT/(${SUFFIXES})")
+    MESSAGE(FATAL_ERROR "MKL_INCLUDE_DIRECTORIES not set. \"mkl.h\" not found in MKL_ROOT/(${SUFFIXES})")
   endif ()
 endif (NOT MKL_ROOT)
 
 if (NOT MKL_ROOT)
   if (CMAKE_CXX_COMPILER_ID MATCHES "Intel")
-    message(FATAL_ERROR "Intel's standard compilervar.sh sets the env variable MKLROOT.\n"
+    MESSAGE(FATAL_ERROR "Intel's standard compilervar.sh sets the env variable MKLROOT.\n"
             "If you are invoking icc without the customary environment\n"
             "you must set the the environment variable or pass cmake MKL_ROOT.")
   else(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
-    message (FATAL_ERROR "ENABLE_MKL is TRUE and mkl directory not found. Set MKL_ROOT." )
+    MESSAGE(FATAL_ERROR "ENABLE_MKL is TRUE and mkl directory not found. Set MKL_ROOT." )
   endif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
 endif (NOT MKL_ROOT)
 
-message("MKL_INCLUDE_DIRECTORIES: ${MKL_INCLUDE_DIRECTORIES}")
+MESSAGE(STATUS "MKL_INCLUDE_DIRECTORIES: ${MKL_INCLUDE_DIRECTORIES}")
 
 if ( NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
   # Finding and setting the MKL_LINK_DIRECTORIES
@@ -45,11 +45,11 @@ if ( NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
   find_library(MKL_LINK_DIRECTORIES "${MKL_FIND_LIB}" HINTS ${MKL_ROOT}
     PATH_SUFFIXES ${SUFFIXES})
   if (NOT MKL_LINK_DIRECTORIES)
-    message(FATAL_ERROR "MKL_LINK_DIRECTORIES not set. ${MKL_FIND_LIB} "
+    MESSAGE(FATAL_ERROR "MKL_LINK_DIRECTORIES not set. ${MKL_FIND_LIB} "
       "not found in MKL_ROOT/(${SUFFIXES})")
   endif ()
   string(REPLACE "/${MKL_FIND_LIB}" "" MKL_LINK_DIRECTORIES ${MKL_LINK_DIRECTORIES})
-  message("MKL_LINK_DIRECTORIES: ${MKL_LINK_DIRECTORIES}")
+  MESSAGE(STATUS "MKL_LINK_DIRECTORIES: ${MKL_LINK_DIRECTORIES}")
   set(MKL_LINKER_FLAGS "-L${MKL_LINK_DIRECTORIES} -Wl,-rpath,${MKL_LINK_DIRECTORIES}")
   set(MKL_LIBRARIES "-lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lpthread -lm -ldl")
 else ( NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
@@ -91,13 +91,12 @@ find_path(MKL_FFTW3 "fftw3.h"
   HINTS ${MKL_INCLUDE_DIRECTORIES}
   PATH_SUFFIXES fftw)
 if(MKL_FFTW3)
-  list(APPEND MKL_INCLUDE_DIRECTORIES ${MKL_FFTW3})
   FILE( WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src_mkl_fftw3.cxx"
     "#include <iostream>\n #include <fftw3.h>\n int main() { return 0; }\n" )
   try_compile(HAVE_MKL_FFTW3 ${CMAKE_BINARY_DIR}
     ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src_mkl_fftw3.cxx
     CMAKE_FLAGS
-    "-DINCLUDE_DIRECTORIES=${MKL_INCLUDE_DIRECTORIES} "
+    "-DINCLUDE_DIRECTORIES=${MKL_FFTW3} "
     "-DLINK_DIRECTORIES=${MKL_LINK_DIRECTORIES}"
     LINK_LIBRARIES "${MKL_LIBRARIES}"
     COMPILE_DEFINITIONS "${MKL_COMPILE_DEFINITIONS}"
@@ -107,14 +106,46 @@ else(MKL_FFTW3)
 endif(MKL_FFTW3)
 
 IF ( HAVE_MKL )
-  SET( MKL_FOUND 1 )
-  SET( MKL_FLAGS ${MKL_COMPILE_DEFINITIONS} )
-  include_directories( ${MKL_INCLUDE_DIRECTORIES} )
+  SET( MKL_FOUND TRUE )
   MESSAGE(STATUS "MKL found: HAVE_MKL=${HAVE_MKL}, HAVE_MKL_VML=${HAVE_MKL_VML}, HAVE_MKL_FFTW3=${HAVE_MKL_FFTW3}")
+
+  #create BLAS_LAPACK target
+  ADD_LIBRARY(Math::BLAS_LAPACK INTERFACE IMPORTED)
+  SET_TARGET_PROPERTIES(Math::BLAS_LAPACK PROPERTIES INTERFACE_COMPILE_DEFINITIONS "HAVE_MKL")
+  IF (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+    SET_TARGET_PROPERTIES(Math::BLAS_LAPACK PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${MKL_INCLUDE_DIRECTORIES}"
+                                                       INTERFACE_LINK_LIBRARIES "${MKL_LINKER_FLAGS} ${MKL_LIBRARIES}")
+  ELSE (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+    SET_TARGET_PROPERTIES(Math::BLAS_LAPACK PROPERTIES INTERFACE_COMPILE_OPTIONS "-mkl"
+                                                       INTERFACE_LINK_LIBRARIES "-mkl")
+  ENDIF (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+
+  IF( HAVE_MKL_VML )
+    #create scalar_vector_functions target
+    ADD_LIBRARY(Math::scalar_vector_functions INTERFACE IMPORTED)
+    SET_TARGET_PROPERTIES(Math::scalar_vector_functions PROPERTIES INTERFACE_COMPILE_DEFINITIONS "HAVE_MKL;HAVE_MKL_VML")
+    IF (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+      SET_TARGET_PROPERTIES(Math::scalar_vector_functions PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${MKL_INCLUDE_DIRECTORIES}"
+                                                                     INTERFACE_LINK_LIBRARIES "${MKL_LINKER_FLAGS} ${MKL_LIBRARIES}")
+    ELSE (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+      SET_TARGET_PROPERTIES(Math::scalar_vector_functions PROPERTIES INTERFACE_COMPILE_OPTIONS "-mkl"
+                                                                     INTERFACE_LINK_LIBRARIES "-mkl")
+    ENDIF (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+  ENDIF( HAVE_MKL_VML )
+
+  IF( HAVE_MKL_FFTW3 )
+    #create FFTW3 target
+    ADD_LIBRARY(Math::FFTW3 INTERFACE IMPORTED)
+    SET_TARGET_PROPERTIES(Math::FFTW3 PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${MKL_FFTW3}"
+                                                 INTERFACE_COMPILE_DEFINITIONS "HAVE_MKL;HAVE_LIBFFTW")
+    IF (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+      SET_TARGET_PROPERTIES(Math::FFTW3 PROPERTIES INTERFACE_LINK_LIBRARIES "${MKL_LINKER_FLAGS} ${MKL_LIBRARIES}")
+    ELSE (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+      SET_TARGET_PROPERTIES(Math::FFTW3 PROPERTIES INTERFACE_COMPILE_OPTIONS "-mkl"
+                                                   INTERFACE_LINK_LIBRARIES "-mkl")
+    ENDIF (NOT CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+  ENDIF( HAVE_MKL_FFTW3 )
 ELSE( HAVE_MKL )
-  SET( MKL_FOUND 0 )
-  SET( MKL_FLAGS )
-  SET( MKL_LIBRARIES )
-  SET( MKL_LINKER_FLAGS )
-  MESSAGE("MKL not found")
+  SET( MKL_FOUND FALSE )
+  MESSAGE(STATUS "MKL not found")
 ENDIF( HAVE_MKL )

CMakeLists.txt

@@ -226,8 +226,6 @@ INCLUDE(${CMAKE_ROOT}/Modules/CheckCXXSymbolExists.cmake)
 INCLUDE(${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
 INCLUDE(${CMAKE_ROOT}/Modules/CheckTypeSize.cmake)
 
-INCLUDE(${PROJECT_CMAKE}/CheckSincos.cmake)
-
 CHECK_FUNCTION_EXISTS(posix_memalign HAVE_POSIX_MEMALIGN)
 
 CHECK_INCLUDE_FILE(dlfcn.h HAVE_DLFCN_H)
@@ -450,34 +448,25 @@ ELSE(CMAKE_TOOLCHAIN_FILE)
    INCLUDE(CMake/FindMKL.cmake)
   ENDIF(ENABLE_MKL)
   IF ( HAVE_MKL )
-    # We found MKL, add the link library
-    SET(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} ${MKL_FLAGS}")
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MKL_FLAGS}")
-    SET(LAPACK_FOUND 1)
-    SET(LAPACK_LIBRARIES "${MKL_LIBRARIES}")
-    SET(LAPACK_LINKER_FLAGS "${MKL_LINKER_FLAGS}")
+    # Skip adding Math::BLAS_LAPACK target which has been imported by FindMKL.
   ELSEIF ( $ENV{CRAYPE_VERSION} MATCHES "." )
     # Cray specific environment variable indicates we are on a cray. Assume libsci will be linked
     # preferable to attempt a compile/link
-    SET(LAPACK_FOUND 1)
     MESSAGE(STATUS "Assuming Cray libsci or other BLAS/LAPACK will be linked by compiler wrappers")
+    ADD_LIBRARY(Math::BLAS_LAPACK INTERFACE IMPORTED)
   ELSE()
-    # Search for Blas/Lapack
-    find_package(LAPACK)
+    # The last search for Blas/Lapack
+    find_package(LAPACK REQUIRED)
     IF("${LAPACK_LIBRARIES}" MATCHES "mkl")
       MESSAGE(FATAL_ERROR "MKL found via LAPACK/BLAS. Please pass -DENABLE_MKL=1 to cmake for full Intel MKL utilization. -DMKL_ROOT may also be needed for the include files to be found.")
     ENDIF()
-  ENDIF()
-  IF(LAPACK_FOUND)
     MESSAGE(STATUS "LAPACK libraries: ${LAPACK_LIBRARIES}")
     MESSAGE(STATUS "LAPACK linker flags: ${LAPACK_LINKER_FLAGS}")
-    SET(LAPACK_LIBRARY ${LAPACK_LIBRARIES} ${LAPACK_LINKER_FLAGS})
-  ELSE()
-    MESSAGE(FATAL_ERROR "Could not find required libraries LAPACK &/or BLAS")
+    SET(LAPACK_LIBRARY ${LAPACK_LINKER_FLAGS} ${LAPACK_LIBRARIES})
+    # Add Math::BLAS_LAPACK target
+    ADD_LIBRARY(Math::BLAS_LAPACK INTERFACE IMPORTED)
+    SET_TARGET_PROPERTIES(Math::BLAS_LAPACK PROPERTIES INTERFACE_LINK_LIBRARIES "${LAPACK_LIBRARY}")
   ENDIF()
-
-  INCLUDE(CMake/FindVectorMath.cmake)
-
 ENDIF(CMAKE_TOOLCHAIN_FILE)
 
 IF (ENABLE_GCOV)
@@ -545,16 +534,31 @@ ENDIF(QMC_MPI)
 # installataions
 # list of libraries to be linked with the main applications using I/O
 
-SET(QMC_UTIL_LIBS ${LAPACK_LIBRARY} ${BLAS_LIBRARY})
-
-# This needs a better place to live. as does all the IF( HAVE_MKL ) stuff
-IF(HAVE_MASS)
-  SET(CMAKE_CXX_FLAGS ${MASS_FLAGS} ${CMAKE_CXX_FLAGS})
-  SET(CMAKE_C_FLAGS ${MASS_FLAGS} ${CMAKE_C_FLAGS})
-  SET(MASS_LIBRARY "${MASS_LINKER_FLAGS} ${MASS_LIBRARIES}")
-  SET(QMC_UTIL_LIBS ${MASS_LIBRARY} ${QMC_UTIL_LIBS})
-ENDIF(HAVE_MASS)
+#-------------------------------------------------------------------
+#  set up scalar/vector math libraries
+#-------------------------------------------------------------------
+SET(ENABLE_MASS FALSE CACHE BOOL "ENABLE MASS scalar and vector math libraries for Power architecture")
+
+# This needs to go before HAVE_SINCOS
+IF(ENABLE_MASS)
+  INCLUDE(CMake/FindIBMMASS.cmake)
+ENDIF(ENABLE_MASS)
+
+IF(NOT HAVE_MASS AND NOT HAVE_MKL_VML)
+  MESSAGE(STATUS "No usable vector math library detected.")
+  ADD_LIBRARY(Math::scalar_vector_functions INTERFACE IMPORTED)
+ENDIF(NOT HAVE_MASS AND NOT HAVE_MKL_VML)
+
+# CheckSincos relies on SINCOS_INCLUDE which may be modified based on vendor libraries
+IF(NOT SINCOS_INCLUDE)
+  SET(SINCOS_INCLUDE cmath)
+ENDIF(NOT SINCOS_INCLUDE)
+MESSAGE(STATUS "SINCOS_INCLUDE : ${SINCOS_INCLUDE}")
+INCLUDE(${PROJECT_CMAKE}/CheckSincos.cmake)
 
+#-------------------------------------------------------------------
+#  set up FFTW3 library
+#-------------------------------------------------------------------
 SET( FFTW_FOUND 0 )
 IF ( HAVE_MKL )
   IF ( HAVE_MKL_FFTW3 )
@@ -566,8 +570,6 @@ IF ( NOT FFTW_FOUND )
 ENDIF()
 IF(FFTW_FOUND)
   SET(HAVE_LIBFFTW 1)
-  INCLUDE_DIRECTORIES(${FFTW_INCLUDE_DIR})
-  SET(QMC_UTIL_LIBS ${QMC_UTIL_LIBS} ${FFTW_LIBRARIES})
   MESSAGE(STATUS "Found FFTW")
 ELSE(FFTW_FOUND)
 #  MESSAGE(STATUS "Disabling FFTW")

src/AFQMC/CMakeLists.txt

@@ -70,6 +70,7 @@ ELSE(ENABLE_CUDA)
 ENDIF(ENABLE_CUDA)
 
 TARGET_LINK_LIBRARIES(afqmc PUBLIC qmcutil)
+TARGET_LINK_LIBRARIES(afqmc PRIVATE Math::BLAS_LAPACK)
 IF(HAVE_MPI)
   TARGET_COMPILE_DEFINITIONS(afqmc PRIVATE "USE_MPI")
 ENDIF(HAVE_MPI)

src/AFQMC/Numerics/tests/CMakeLists.txt

@@ -25,7 +25,7 @@ SET(UTEST_NAME deterministic-unit_test_${SRC_DIR})
   ADD_EXECUTABLE(${UTEST_EXE} test_dense_numerics.cpp test_ma_blas.cpp
 test_sparse_numerics.cpp test_sparse_numerics_native.cpp)
 #ENDIF(ENABLE_CUDA)
-TARGET_LINK_LIBRARIES(${UTEST_EXE} afqmc)
+TARGET_LINK_LIBRARIES(${UTEST_EXE} afqmc Math::BLAS_LAPACK)
 
 #ADD_TEST(NAME ${UTEST_NAME} COMMAND "${QMCPACK_UNIT_TEST_DIR}/${UTEST_EXE}")
 ADD_UNIT_TEST(${UTEST_NAME} "${QMCPACK_UNIT_TEST_DIR}/${UTEST_EXE}")

src/CMakeLists.txt

@@ -254,7 +254,7 @@ ENDIF()
 
   ADD_LIBRARY(qmcbase ${PARTICLE} ${PARTICLEIO})
 
-  TARGET_LINK_LIBRARIES(qmcbase PRIVATE qmcminimalcontainers)
+  TARGET_LINK_LIBRARIES(qmcbase PRIVATE qmcminimalcontainers Math::BLAS_LAPACK Math::scalar_vector_functions)
 
   TARGET_LINK_LIBRARIES(qmcbase PUBLIC qmcutil)
 

src/Lattice/tests/CMakeLists.txt

@@ -18,7 +18,7 @@ SET(UTEST_NAME deterministic-unit_test_${SRC_DIR})
 
 
 ADD_EXECUTABLE(${UTEST_EXE} test_ParticleBConds.cpp test_CrystalLattice.cpp test_LRBreakupParameters.cpp)
-TARGET_LINK_LIBRARIES(${UTEST_EXE} qmcutil)
+TARGET_LINK_LIBRARIES(${UTEST_EXE} qmcutil Math::scalar_vector_functions)
 
 #ADD_TEST(NAME ${UTEST_NAME} COMMAND "${QMCPACK_UNIT_TEST_DIR}/${UTEST_EXE}")
 ADD_UNIT_TEST(${UTEST_NAME} "${QMCPACK_UNIT_TEST_DIR}/${UTEST_EXE}")

src/Numerics/tests/CMakeLists.txt

@@ -30,7 +30,7 @@ SET(UTEST_SRCS test_grid_functor.cpp test_stdlib.cpp test_bessel.cpp
 ADD_EXECUTABLE(${UTEST_EXE} ${UTEST_SRCS})
 
 
-TARGET_LINK_LIBRARIES(${UTEST_EXE} qmcutil)
+TARGET_LINK_LIBRARIES(${UTEST_EXE} qmcutil Math::scalar_vector_functions)
 
 #ADD_TEST(NAME ${UTEST_NAME} COMMAND "${QMCPACK_UNIT_TEST_DIR}/${UTEST_EXE}")
 ADD_UNIT_TEST(${UTEST_NAME} "${QMCPACK_UNIT_TEST_DIR}/${UTEST_EXE}")