IFEM/CMakeLists.txt

PROJECT(IFEM)

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)

# Required defines (well, PROFILE_LEVEL is not actually required, but...)
SET(CMAKE_CXX_FLAGS "-Dreal=double -DepsZ=1.0e-12 -DPROFILE_LEVEL=3")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DINDEX_CHECK=2")
IF(VERBOSE_DEBUG GREATER 0)
  SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSP_DEBUG=${VERBOSE_DEBUG}")
ENDIF(VERBOSE_DEBUG GREATER 0)

ENABLE_LANGUAGE(Fortran)
IF(CMAKE_Fortran_COMPILER MATCHES ifort)
  SET(LANGUAGE_LIBS -lifcore)
ENDIF(CMAKE_Fortran_COMPILER MATCHES ifort)

ENABLE_LANGUAGE(CXX)
IF(CMAKE_CXX_COMPILER MATCHES icpc)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_MKL")
ELSE(CMAKE_CXX_COMPILER MATCHES icpc)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CBLAS")
ENDIF(CMAKE_CXX_COMPILER MATCHES icpc)

ENABLE_TESTING()

# Add local modules
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
                      ${CMAKE_SOURCE_DIR}/cmake/Modules)

# Required packages
FIND_PACKAGE(Boost REQUIRED)
FIND_PACKAGE(GoTools REQUIRED)
FIND_PACKAGE(GoTrivariate REQUIRED)
FIND_PACKAGE(LAPACK REQUIRED)
FIND_PACKAGE(ARPACK REQUIRED)

# Optional packages
IF(${ENABLE_PETSC})
  FIND_PACKAGE(Petsc)
ENDIF(${ENABLE_PETSC})
IF(NOT "${DISABLE_SUPERLU}")
  FIND_PACKAGE(SuperLU)
ENDIF(NOT "${DISABLE_SUPERLU}")
IF(${ENABLE_SAMG})
  FIND_PACKAGE(SAMG)
ENDIF(${ENABLE_SAMG})
FIND_PACKAGE(VTFWriter)
IF(NOT "${DISABLE_HDF5}")
  FIND_PACKAGE(HDF5)
ENDIF(NOT "${DISABLE_HDF5}")

# Required libraries
SET(DEPLIBS ${GoTrivariate_LIBRARIES} ${GoTools_LIBRARIES}
            ${ARPACK_LIBRARIES} ${LAPACK_LIBRARIES}
            ${Boost_LIBRARIES} ${LANGUAGE_LIBS}
)

# Required include directories
SET(INCLUDES
  ${Boost_INCLUDE_DIRS}
  ${GoTools_INCLUDE_DIRS}
  ${GoTrivariate_INCLUDE_DIRS}
  ${PROJECT_SOURCE_DIR}/src/ASM
  ${PROJECT_SOURCE_DIR}/src/Eig
  ${PROJECT_SOURCE_DIR}/src/Integrands
  ${PROJECT_SOURCE_DIR}/src/LinAlg
  ${PROJECT_SOURCE_DIR}/src/SIM
  ${PROJECT_SOURCE_DIR}/src/Utility
  ${PROJECT_SOURCE_DIR}/3rdparty/tinyxml
)

# MKL
IF(CMAKE_CXX_COMPILER MATCHES icpc)
  FIND_PACKAGE(MKL REQUIRED)
  SET(DEPLIBS ${DEPSLIBS} ${MKL_LIBRARIES})
  SET(INCLUDES ${INCLUDES} ${MKL_INCLUDES})
ENDIF(CMAKE_CXX_COMPILER MATCHES icpc)

IF(SuperLU_MT_LIBRARIES AND SuperLU_MT_INCLUDES AND "${ENABLE_SUPERLU_MT}")
  FIND_PACKAGE(Threads REQUIRED)
  SET(DEPLIBS ${DEPLIBS} ${SuperLU_MT_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
  SET(INCLUDES ${INCLUDES} ${SuperLU_MT_INCLUDES})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SUPERLU_MT")
ELSEIF(SuperLU_LIBRARIES AND SuperLU_INCLUDES)
  SET(DEPLIBS ${DEPLIBS} ${SuperLU_LIBRARIES})
  SET(INCLUDES ${INCLUDES} ${SuperLU_INCLUDES})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SUPERLU")
ENDIF(SuperLU_MT_LIBRARIES AND SuperLU_MT_INCLUDES AND "${ENABLE_SUPERLU_MT}")

IF(PETSC_LIBRARIES AND PETSC_INCLUDE_DIR)
  SET(INCLUDES ${INCLUDES} ${PETSC_INCLUDE_DIR} ${PETSCCONF_INCLUDE_DIR})
  SET(DEPLIBS ${DEPLIBS} ${PETSC_LIBRARIES})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_PETSC")
  IF(${ENABLE_PARALLEL_PETSC})
    FIND_PACKAGE(MPI REQUIRED)
    SET(INCLUDES ${INCLUDES} ${MPI_INCLUDE_PATH})
    SET(DEPLIBS ${DEPLIBS} ${MPI_LIBRARIES})
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPARALLEL_PETSC")
  ENDIF(${ENABLE_PARALLEL_PETSC})
  FIND_PACKAGE(SLEPc)
  IF(SLEPC_LIBRARIES AND SLEPC_INCLUDES)
    SET(INCLUDES ${INCLUDES} ${SLEPC_INCLUDES})
    SET(DEPLIBS ${DEPLIBS} ${SLEPC_LIBRARIES})
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SLEPC")
  ENDIF(SLEPC_LIBRARIES AND SLEPC_INCLUDES)
ENDIF(PETSC_LIBRARIES AND PETSC_INCLUDE_DIR)

IF(SAMG_LIBRARIES AND SAMG_INCLUDES)
  SET(DEPLIBS ${DEPLIBS} ${SAMG_LIBRARIES})
  SET(INCLUDES ${INCLUDES} ${SAMG_INCLUDES})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SAMG -DSAMG_UNIX_LINUX=1 -DSAMG_LCASE_USCORE")
ENDIF(SAMG_LIBRARIES AND SAMG_INCLUDES)

IF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES)
  SET(DEPLIBS ${DEPLIBS} ${VTFWRITER_LIBRARIES})
  SET(INCLUDES ${INCLUDES} ${VTFWRITER_INCLUDES})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_VTFAPI=${VTFAPI}")
ENDIF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES)

IF(HDF5_LIBRARIES AND HDF5_INCLUDE_DIR)
  SET(DEPLIBS ${DEPLIBS} ${HDF5_LIBRARIES})
  SET(INCLUDES ${INCLUDES} ${HDF5_INCLUDE_DIR})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_HDF5=1")
ENDIF(HDF5_LIBRARIES AND HDF5_INCLUDE_DIR)

INCLUDE_DIRECTORIES(${INCLUDES})

SET(EXECUTABLE_OUTPUT_PATH bin)
SET(LIBRARY_OUTPUT_PATH lib)

IF(NOT WIN32)
  # Emit position-independent code, suitable for dynamic linking
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
  # Enable all warnings
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-parentheses")
ENDIF(NOT WIN32)

# Make the IFEM library
FILE(GLOB_RECURSE IFEM_SRCS ${PROJECT_SOURCE_DIR}/src/*.[Cf]
                            ${PROJECT_SOURCE_DIR}/3rdparty/*.C)
ADD_LIBRARY(IFEM ${IFEM_SRCS})

# Make some Apps
FILE(GLOB_RECURSE Poisson_SRCS ${PROJECT_SOURCE_DIR}/Apps/Poisson/*.C)
ADD_EXECUTABLE(Poisson ${Poisson_SRCS})
TARGET_LINK_LIBRARIES(Poisson IFEM ${DEPLIBS})

FILE(GLOB_RECURSE LinEl_SRCS
  ${PROJECT_SOURCE_DIR}/Apps/LinearElasticity/main_LinEl3D.C
  ${PROJECT_SOURCE_DIR}/Apps/LinearElasticity/SIMLinEl*.C)
ADD_EXECUTABLE(LinEl ${LinEl_SRCS})
TARGET_LINK_LIBRARIES(LinEl IFEM ${DEPLIBS})

IF(HDF5_LIBRARIES AND VTFWRITER_LIBRARIES)
  FILE(GLOB_RECURSE HDF2VTF_SRCS ${PROJECT_SOURCE_DIR}/Apps/HDF5toVTx/*.C)
  ADD_EXECUTABLE(HDF5toVTx ${HDF2VTF_SRCS})
  TARGET_LINK_LIBRARIES(HDF5toVTx IFEM ${DEPLIBS})
ENDIF(HDF5_LIBRARIES AND VTFWRITER_LIBRARIES)

# Regression tests
FILE(GLOB_RECURSE LINEL_TESTFILES "${PROJECT_SOURCE_DIR}/Apps/LinearElasticity/Test/*.reg")
FOREACH(TESTFILE ${LINEL_TESTFILES})
  ADD_TEST(${TESTFILE} ${PROJECT_SOURCE_DIR}/test/regtest.sh "${CMAKE_BINARY_DIR}/${EXECUTABLE_OUTPUT_PATH}/LinEl" "${TESTFILE}")
ENDFOREACH()

FILE(GLOB_RECURSE POISSON_TESTFILES "${PROJECT_SOURCE_DIR}/Apps/Poisson/Test/*.reg")
FOREACH(TESTFILE ${POISSON_TESTFILES})
  ADD_TEST(${TESTFILE} ${PROJECT_SOURCE_DIR}/test/regtest.sh "${CMAKE_BINARY_DIR}/${EXECUTABLE_OUTPUT_PATH}/Poisson" "${TESTFILE}")
ENDFOREACH()

IF(NOT IFEM_INSTALL_PREFIX)
  SET(IFEM_INSTALL_PREFIX $ENV{HOME})
ENDIF(NOT IFEM_INSTALL_PREFIX)

# 'install' target
IF(WIN32)
  # TODO
ELSE(WIN32)
  # lib
  INSTALL(TARGETS IFEM DESTINATION ${IFEM_INSTALL_PREFIX}/lib)

  # headers
  FILE(GLOB_RECURSE IFEM_HEADERS src/ASM/*.h src/Integrands/*.h
                                 src/LinAlg/*.h src/SIM/*.h src/Utility/*.h)
  INSTALL(FILES ${IFEM_HEADERS}
          DESTINATION ${IFEM_INSTALL_PREFIX}/include/IFEM)

  FILE(GLOB_RECURSE LOCAL_CMAKE_MODULES cmake/Modules/*.cmake)

  # cmake modules
  INSTALL(FILES ${LOCAL_CMAKE_MODULES} DESTINATION ${IFEM_INSTALL_PREFIX}/cmake/Modules)
ENDIF(WIN32)