CMakeLists.txt

#
# CMakeLists.txt file for NimbleSM
#

Cmake_minimum_required(VERSION 3.1)
project(NimbleSM CXX C Fortran)

enable_testing()

set(SRC_DIR ${CMAKE_SOURCE_DIR}/src)

SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")

if (HAVE_DARMA)
  find_package(DARMA REQUIRED COMPONENTS ${DARMA_BACKEND_PKG})
  if (DARMA_FOUND)
    MESSAGE("-- Compiling with DARMA:")
    MESSAGE("       DARMA_BACKEND_CXX_COMPILER: ${DARMA_BACKEND_CXX_COMPILER}")
    MESSAGE("       DARMA_BACKEND_CXX_FLAGS: ${DARMA_BACKEND_CXX_FLAGS}")
    MESSAGE("       DARMA_INCLUDE_DIRS: ${DARMA_INCLUDE_DIRS}")
    MESSAGE("       DARMA_LIBRARIES: ${DARMA_LIBRARIES}")
    include_directories( ${DARMA_INCLUDE_DIRS} )
    set (CMAKE_CXX_COMPILER ${DARMA_BACKEND_CXX_COMPILER})
    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DARMA_BACKEND_CXX_FLAGS}")
    ADD_DEFINITIONS(-DNIMBLE_HAVE_DARMA)
    SET(NIMBLE_HAVE_DARMA TRUE)
  endif()
else()
  MESSAGE("-- DARMA is NOT enabled.")
  SET(NIMBLE_HAVE_DARMA FALSE)
  SET(NIMBLE_HAVE_CHARM FALSE)
  SET(DARMA_BACKEND_LIBRARIES)
endif()

# Optional DARMA dependencies
#[[
IF(HAVE_DARMA)
  ADD_DEFINITIONS(-DNIMBLE_HAVE_DARMA)
  SET(NIMBLE_HAVE_DARMA TRUE)
  if (DARMA_BACKEND_PKG)
    find_package (${DARMA_BACKEND_PKG}
        PATHS ${DARMA_BACKEND_ROOT})
    if (NOT ${DARMA_BACKEND_PKG}_FOUND)
      message (FATAL_ERROR
        "Error: DARMA backend package could not be found; use "
        "${DARMA_BACKEND_PKG}_DIR= to specify path to "
        "${DARMA_BACKEND_PKG}Config.cmake file")
    endif ()
    #set (CMAKE_CXX_COMPILER ${DARMA_BACKEND_CXX_COMPILER})
    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DARMA_BACKEND_CXX_FLAGS}")
    MESSAGE("frontend dir: ${DARMA_FRONTEND_INCLUDE_DIR}")
    include_directories( ${DARMA_FRONTEND_INCLUDE_DIR} ${DARMA_BACKEND_INCLUDE_DIRS} )
    link_directories( ${DARMA_BACKEND_LIBRARY_DIRS} )
  else()  # not using cmake package
    message(FATAL_ERROR
      "Specify the DARMA backend package using -DDARMA_BACKEND_PKG=")
  endif()
  IF(${DARMA_BACKEND_PKG} STREQUAL DarmaCharmBackend)
    ADD_DEFINITIONS(-DNIMBLE_HAVE_CHARM)
    SET(NIMBLE_HAVE_CHARM TRUE)
  ENDIF()
  MESSAGE("-- Compiling with DARMA:")
  MESSAGE("       DARMA_BACKEND_PKG: ${DARMA_BACKEND_PKG}")
  MESSAGE("       DARMA_BACKEND_CXX_COMPILER: ${DARMA_BACKEND_CXX_COMPILER}")
  MESSAGE("       DARMA_BACKEND_CXX_FLAGS: ${DARMA_BACKEND_CXX_FLAGS}")
  MESSAGE("       DARMA_BACKEND_INCLUDE_DIRS: ${DARMA_BACKEND_INCLUDE_DIRS}")
  MESSAGE("       DARMA_BACKEND_LIBRARY_DIRS: ${DARMA_BACKEND_LIBRARY_DIRS}")
  MESSAGE("       DARMA_BACKEND_LIBRARIES: ${DARMA_BACKEND_LIBRARIES}")
ELSE()
  MESSAGE("-- DARMA is NOT enabled.")
  SET(NIMBLE_HAVE_DARMA FALSE)
  SET(NIMBLE_HAVE_CHARM FALSE)
  SET(DARMA_BACKEND_LIBRARIES)
ENDIF()
#]]

# Optional dependency for pure MPI build (no Trilinos)
IF(USE_PURE_MPI)
  find_package(MPI REQUIRED)
  include_directories(${MPI_INCLUDE_PATH})
  link_libraries(${MPI_LIBRARIES})

  ADD_DEFINITIONS(-DNIMBLE_HAVE_MPI)
  SET(NIMBLE_HAVE_MPI TRUE)
  MESSAGE("-- Compiling with MPI (no Trilinos)")
ENDIF()

# Optional BVH dependency
IF(HAVE_BVH)
  ADD_DEFINITIONS(-DNIMBLE_HAVE_BVH)
  IF(BVH_DEBUG_LEVEL)
    ADD_DEFINITIONS(-DBVH_DEBUG_LEVEL=${BVH_DEBUG_LEVEL})
  ENDIF()
  SET(NIMBLE_HAVE_BVH TRUE)
  SET(bvh_DIR CACHE PATH "Path to BVH install directory")
  FIND_PACKAGE(bvh REQUIRED)
  MESSAGE("-- Compiling with BVH:")
  MESSAGE("       TinyMath_DIR: ${TinyMath_DIR}")
  MESSAGE("       BVH_DIR: ${bvh_DIR}")
  IF(NIMBLE_HAVE_MPI)
    MESSAGE("       Using parallel collision detection (NIMBLE_HAVE_MPI=ON)")
  ELSE()
    MESSAGE("       Using only serial collision detection (NIMBLE_HAVE_MPI=OFF)")
  ENDIF()
  set(bvh_LIBS bvh::bvh)
ELSE()
  MESSAGE("-- BVH is NOT enabled.")
  SET(NIMBLE_HAVE_BVH FALSE)
  set(bvh_LIBS)
ENDIF()

# Optional Trilinos dependencies
IF(HAVE_TRILINOS)
  ADD_DEFINITIONS(-DNIMBLE_HAVE_TRILINOS)
  SET(NIMBLE_HAVE_TRILINOS TRUE)
  ADD_DEFINITIONS(-DNIMBLE_HAVE_EXODUS)
  SET(NIMBLE_HAVE_EXODUS TRUE)
  SET(TRILINOS_DIR CACHE PATH "Path to Trilinos install directory")
  SET(CMAKE_PREFIX_PATH ${TRILINOS_DIR} ${CMAKE_PREFIX_PATH})
  FIND_PACKAGE(Trilinos REQUIRED)
  MESSAGE("-- Compiling with Trilinos:")
  MESSAGE("       Trilinos_DIR: ${Trilinos_DIR}")
  MESSAGE("       Trilinos_VERSION: ${Trilinos_VERSION}")
  MESSAGE("       Trilinos_TPL_LIST: ${Trilinos_TPL_LIST}")
#  MESSAGE("       Trilinos_PACKAGE_LIST: ${Trilinos_PACKAGE_LIST}")
#  MESSAGE("       Trilinos_TPL_INCLUDE_DIRS: ${Trilinos_TPL_INCLUDE_DIRS}")
#  MESSAGE("       Trilinos_TPL_LIBRARIES: ${Trilinos_TPL_LIBRARIES}")
#  MESSAGE("       Trilinos_TPL_LIBRARY_DIRS: ${Trilinos_TPL_LIBRARY_DIRS}")
#  MESSAGE("       Trilinos_BUILD_SHARED_LIBS: ${Trilinos_BUILD_SHARED_LIBS}")
#  MESSAGE("       Trilinos_CXX_COMPILER_FLAGS: ${Trilinos_CXX_COMPILER_FLAGS}")
#  MESSAGE("       Trilinos_LIBRARIES: ${Trilinos_LIBRARIES}")
#  MESSAGE("       Trilinos_INCLUDE_DIRS: ${Trilinos_INCLUDE_DIRS}")
#  MESSAGE("       Trilinos_LIBRARY_DIRS: ${Trilinos_LIBRARY_DIRS}")
  include_directories(${Trilinos_INCLUDE_DIRS} ${Trilinos_TPL_INCLUDE_DIRS})
  link_directories(${Trilinos_LIBRARY_DIRS} ${Trilinos_TPL_LIBRARY_DIRS})
ELSE()
  MESSAGE("-- Trilinos is NOT enabled.")
  SET(NIMBLE_HAVE_TRILINOS FALSE)
ENDIF()

# Qthreads library dependencies
IF(HAVE_QTHREADS)
  IF(QTHREADS_INCLUDE_DIR AND QTHREADS_LIB_DIR)
    MESSAGE("-- Compiling with Qthreads:")
    MESSAGE("       QTHREADS_INCLUDE_DIR: ${QTHREADS_INCLUDE_DIR}")
    MESSAGE("       QTHREADS_LIB_DIR: ${QTHREADS_LIB_DIR}")
    ADD_DEFINITIONS(-DNIMBLE_HAVE_QTHREADS)
    SET(NIMBLE_HAVE_QTHREADS TRUE)
    include_directories(${QTHREADS_INCLUDE_DIR})
    link_directories(${QTHREADS_LIB_DIR})
    set(Qthreads_LIBS qthread)
  ELSE()
    MESSAGE("-- Qthreads is NOT enabled.")
    set(Qthreads_LIBS )
  ENDIF()
ENDIF()

# Optional Kokkos dependency
if(HAVE_KOKKOS)
  if(KOKKOS_ROOT_DIR)
    message("-- Compiling with Kokkos")
    add_subdirectory(${KOKKOS_ROOT_DIR} ./kokkos)
    include_directories(${Kokkos_INCLUDE_DIRS_RET})
    set(NIMBLE_KOKKOS_LIBS kokkos)
    add_definitions(-DNIMBLE_HAVE_KOKKOS)
    set(NIMBLE_HAVE_KOKKOS TRUE)
    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${KOKKOS_CXX_FLAGS}")
    set (CMAKE_LD_FLAGS "${CMAKE_LD_FLAGS} ${KOKKOS_LD_FLAGS}")
  else()
    find_package(Kokkos REQUIRED)
    set(NIMBLE_KOKKOS_LIBS kokkos)
    add_definitions(-DNIMBLE_HAVE_KOKKOS)
    set(NIMBLE_HAVE_KOKKOS TRUE)
    MESSAGE("-- Compiling with Kokkos:")
    MESSAGE("       Kokkos_DIR: ${Kokkos_DIR}")
    #message(FATAL_ERROR "\n**** Expected KOKKOS_ROOT_DIR")
  endif()
else()
  message("-- Kokkos is NOT enabled.")
  set(NIMBLE_HAVE_KOKKOS FALSE)
  set(NIMBLE_KOKKOS_LIBS)
endif()

if(HAVE_NIMBLE_EXTRAS)
  if(NIMBLE_EXTRAS_DIR)
    include(${NIMBLE_EXTRAS_DIR}/CMakeLists.txt)
    add_subdirectory(${NIMBLE_EXTRAS_DIR}/extras_unit_tests extras_unit_tests)
    message("-- Compiling with Nimble Extras:")
    message("       NIMBLE_EXTRAS_DIR: ${NIMBLE_EXTRAS_DIR}")
    message("       NIMBLE_EXTRAS_LIBS: ${NIMBLE_EXTRAS_LIBS}")
    add_definitions(-DNIMBLE_HAVE_EXTRAS)
    set(NIMBLE_HAVE_EXTRAS TRUE)
  else()
    message(FATAL_ERROR "\n**** Error:  Expected NIMBLE_EXTRAS_DIR.\n")
    set(NIMBLE_EXTRAS_SOURCES )
    set(NIMBLE_EXTRAS_LIBS )
endif()
endif()

# Temporary workaround for nvida builds
if(NIMBLE_NVIDIA_BUILD)
  add_definitions(-DNIMBLE_NVIDIA_BUILD)
  set(NIMBLE_NVIDIA_BUILD TRUE)
endif()

# Exodus library dependencies
IF(NOT HAVE_TRILINOS AND NOT HAVE_NIMBLE_EXTRAS)
  IF(EXODUS_INCLUDE_DIR AND EXODUS_LIB_DIR)
    MESSAGE("-- Compiling with Exodus:")
    MESSAGE("       EXODUS_INCLUDE_DIR: ${EXODUS_INCLUDE_DIR}")
    MESSAGE("       EXODUS_LIB_DIR: ${EXODUS_LIB_DIR}")
    ADD_DEFINITIONS(-DNIMBLE_HAVE_EXODUS)
    SET(NIMBLE_HAVE_EXODUS TRUE)
    include_directories(${EXODUS_INCLUDE_DIR})
    link_directories(${EXODUS_LIB_DIR})
    set(Exodus_LIBS exodus netcdf)
#    set(Exodus_LIBS charm_kv darma_charm_backend exodus netcdf hdf5_hl hdf5 z)
  ELSE()
    MESSAGE("-- EXODUS is NOT enabled.")
    set(Exodus_LIBS )
  ENDIF()
ENDIF()

IF(CRAY)
  set(Exodus_LIBS ${Exodus_LIBS} hdf5_hl hdf5 z)
ENDIF()

add_subdirectory(src)
add_subdirectory(test)
add_subdirectory(examples)