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 -mkl=sequential")
ELSE(CMAKE_CXX_COMPILER MATCHES icpc)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CBLAS")
  FIND_PACKAGE(LAPACK REQUIRED)
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(GoTools REQUIRED)
FIND_PACKAGE(GoTrivariate REQUIRED)
FIND_PACKAGE(ARPACK REQUIRED)

# Mimimum GoTools version
IF(GoTools_VERSION_MAJOR LESS 3 OR NOT GoTools_VERSION_MAJOR)
  MESSAGE(FATAL_ERROR "GoTools >= 3.0.0 required. bailing")
ENDIF(GoTools_VERSION_MAJOR LESS 3 OR NOT GoTools_VERSION_MAJOR)

# Optional packages
IF(${ENABLE_PETSC})
  FIND_PACKAGE(Petsc)
ENDIF(${ENABLE_PETSC})
IF(NOT "${DISABLE_SUPERLU}")
  FIND_PACKAGE(SuperLU)
ENDIF(NOT "${DISABLE_SUPERLU}")
IF(${ENABLE_SPR})
  FIND_PACKAGE(SPR)
ENDIF(${ENABLE_SPR})
IF(${ENABLE_SAMG})
  FIND_PACKAGE(SAMG)
ENDIF(${ENABLE_SAMG})
FIND_PACKAGE(VTFWriter)
IF(NOT "${DISABLE_HDF5}")
  FIND_PACKAGE(HDF5)
ENDIF(NOT "${DISABLE_HDF5}")
IF(NOT "${DISABLE_LRSPLINE}")
  FIND_PACKAGE(LRSpline)
ENDIF(NOT "${DISABLE_LRSPLINE}")
IF(NOT "${DISABLE_OPENMP}")
  FIND_PACKAGE(OpenMP)
ENDIF(NOT "${DISABLE_OPENMP}")

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

# Required include directories
SET(INCLUDES
  ${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
  ${PROJECT_SOURCE_DIR}/3rdparty/expreval
)

# Set libraries, include directories and compiler flags from optional packages

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(SPR_LIBRARIES)
  SET(DEPLIBS ${DEPLIBS} ${SPR_LIBRARIES})
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SPR -DUSE_F77SAM")
ENDIF(SPR_LIBRARIES)

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)

IF(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS)
  SET(DEPLIBS ${DEPLIBS} ${LRSpline_LIBRARIES})
  SET(INCLUDES
    ${INCLUDES}
    ${LRSpline_INCLUDE_DIRS}
    ${PROJECT_SOURCE_DIR}/src/ASM/LR)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_LRSPLINE=1")
ENDIF(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS)

IF(OPENMP_FOUND)
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -DUSE_OPENMP")
ENDIF(OPENMP_FOUND)

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)

# Additional compiler flags required by GoTools
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GoTools_CXX_FLAGS}")

# Make the IFEM library
FILE(GLOB_RECURSE IFEM_SRCS ${PROJECT_SOURCE_DIR}/src/*.[Cf]
                            ${PROJECT_SOURCE_DIR}/3rdparty/*.C
                            ${PROJECT_SOURCE_DIR}/3rdparty/*.cpp)
IF(NOT(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS))
  string(REGEX REPLACE "${PROJECT_SOURCE_DIR}/src/ASM/LR/[^;]*" "" IFEM_SRCS "${IFEM_SRCS}")
ENDIF(NOT(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS))
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)
  # applications
  SET(INSTALL_TARGETS Poisson LinEl)
  IF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES AND
     HDF5_LIBRARIES AND VTFWRITER_LIBRARIES)
    SET(INSTALL_TARGETS ${INSTALL_TARGETS} HDF5toVTx) 
  ENDIF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES AND
        HDF5_LIBRARIES AND VTFWRITER_LIBRARIES)
  INSTALL(TARGETS ${INSTALL_TARGETS}
          DESTINATION ${IFEM_INSTALL_PREFIX}/bin)

  # lib
  INSTALL(TARGETS IFEM DESTINATION ${IFEM_INSTALL_PREFIX}/lib)

  # headers
  FILE(GLOB IFEM_HEADERS src/ASM/AlgEqSystem.h src/ASM/ASMbase.h
                         src/ASM/ASMenums.h src/ASM/ASMmxBase.h
                         src/ASM/ASMstruct.h src/ASM/ElmMats.h src/ASM/ElmNorm.h
                         src/ASM/Field.h src/ASM/Fields.h
                         src/ASM/FiniteElement.h src/ASM/GlbNorm.h
                         src/ASM/GlobalIntegral.h src/ASM/IntegrandBase.h
                         src/ASM/Integrand.h src/ASM/Lagrange.h
                         src/ASM/LocalIntegral.h src/ASM/SAMpatch.h
                         src/ASM/TimeDomain.h
                         src/Integrands/*.h src/LinAlg/*.h src/SIM/*.h
                         src/Utility/*.h)
  INSTALL(FILES ${IFEM_HEADERS}
          DESTINATION ${IFEM_INSTALL_PREFIX}/include/IFEM)

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