CMakeLists.txt

cmake_minimum_required(VERSION 2.8)

project(MOOPS)

IF (${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
       message(FATAL_ERROR "Rejecting in-place build. Please use a build directory")
ENDIF()

INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR})
SET(APP_LIBS "" CACHE INTERNAL "")

#FindParaView
OPTION(USE_PV_COPROCESSOR "Use Paraview Coprocessor" OFF)
IF(USE_PV_COPROCESSOR)
    FIND_PACKAGE(ParaView REQUIRED)
    INCLUDE(${PARAVIEW_USE_FILE})
    INCLUDE_DIRECTORIES(${VTK_MPI_INCLUDE_DIR})
    IF(NOT VTK_MPI_INCLUDE_DIR)
        MESSAGE(SEND_ERROR "Must build ParaView with MPI.")
    ENDIF()
    SET(APP_LIBS ${APP_LIBS} vtkIO vtkRendering vtkGraphics vtkCommon vtkCoProcessor vtkDICOMParser vtkNetCDF vtkmetaio vtksqlite vtkpng vtkjpeg vtktiff vtkexpat vtkftgl vtkverdict vtklibxml2 vtkalglib vtkexoIIc VPIC Cosmo)
    MESSAGE(STATUS "Enabling Paraview Coprocessor and VTK")
    ADD_DEFINITIONS(-DUSE_PV_COPROCESSOR)
ENDIF()

#FindVTK
IF(NOT USE_PV_COPROCESSOR)
    FIND_PACKAGE(VTK REQUIRED)
    IF(VTK_FOUND)
        INCLUDE(${VTK_USE_FILE})
        SET(APP_LIBS ${APP_LIBS} vtkIO vtkCommon)
        
        MESSAGE(STATUS "Enabling VTK")
    ENDIF(VTK_FOUND)
ENDIF()

# FindQt4
OPTION(USE_QT_GUI "Build with QT4 GUI." OFF)
IF(USE_QT_GUI)
    FIND_PACKAGE(Qt4 REQUIRED)
    SET(QT_USE_QTOPENGL TRUE)
    INCLUDE(${QT_USE_FILE})
    ADD_DEFINITIONS(${QT_DEFINITIONS} -DUSE_QT_GUI)
    SET(APP_LIBS ${APP_LIBS} gui)
    if(VTK_FOUND)
        SET(APP_LIBS ${APP_LIBS} QVTK vtkRendering vtkGraphics)
    endif()
    ADD_SUBDIRECTORY(gui)
    MESSAGE(STATUS "Enabling QT4 GUI")
ENDIF()

#FindMPI
option(USE_MPI "Use MPI" OFF)
IF(USE_MPI)
    FIND_PACKAGE(MPI REQUIRED)
    MESSAGE(STATUS "Enabling MPI")
    if(MPI_CXX_FOUND)
        set(CMAKE_CXX_COMPILER ${MPI_CXX_COMPILER})
    endif()
    if(MPI_C_FOUND)
        set(CMAKE_C_COMPILER ${MPI_C_COMPILER})
    endif()
    INCLUDE_DIRECTORIES(${MPI_CXX_INCLUDE_PATH})
ENDIF()

#FindCUDA
OPTION(USE_CUDA "Use the cuda kernels." OFF)
IF(USE_CUDA)
  FIND_PACKAGE(CUDA REQUIRED)
  INCLUDE(cmake/cudaDevicesProps.cmake)
  get_cuda_device_prop("VERSION" 4.1 CUDA_SUPPORT_4.1)
  get_cuda_device_prop("MAJOR_MINOR" 1.1 CUDA_SUPPORT_1.1)
  if(CUDA_SUPPORT_4.1 AND CUDA_SUPPORT_1.1)
    ADD_DEFINITIONS(-DCUDA_ENABLE_MEMORY_MAPPING)
  ENDIF()
    
  SET(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -gencode arch=compute_20,code=sm_20 -use_fast_math)
  IF(NOT CMAKE_COMPILER_IS_GNUCXX)
    SET(CUDA_PROPAGATE_HOST_FLAGS OFF)
  ENDIF()
  ADD_SUBDIRECTORY(math/fluid_solver/stokes/nbody_gpu)
  ADD_DEFINITIONS(-DUSE_CUDA)
  SET(APP_LIBS ${APP_LIBS} cudaStokesSolver)
  MESSAGE(STATUS "Enabling CUDA ${CUDA_VERSION}")

ENDIF()

INCLUDE(CheckCXXCompilerFlag)
IF(CMAKE_COMPILER_IS_GNUCXX)
    OPTION(ENABLE_WARNINGS "Enable/Disable Warnings in g++" OFF)
    IF(ENABLE_WARNINGS)
      SET(G++_WARNINGS "-Weffc++ -Wnon-virtual-dtor -Wno-long-long -ansi -Wundef -Wcast-align -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wold-style-cast")
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${G++_WARNINGS}")
    ENDIF()
    OPTION(ENABLE_EXTRA_OPT_FLAGS "Enable/Disable Flags in g++" OFF)
    IF(ENABLE_EXTRA_OPT_FLAGS)
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions -fno-check-new -fno-common -fstrict-aliasing -ffast-math -funroll-loops -fforce-addr")
        check_cxx_compiler_flag("-Wno-variadic-macros" COMPILER_SUPPORT_WNOVARIADICMACRO)
        IF(COMPILER_SUPPORT_WNOVARIADICMACRO)
            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-variadic-macros")
        ENDIF()

        check_cxx_compiler_flag("-Wextra" COMPILER_SUPPORT_WEXTRA)
        IF(COMPILER_SUPPORT_WEXTRA)
            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra")
        ENDIF()

        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
    ENDIF()
    check_cxx_compiler_flag("-fopenmp" CXXCOMPILER_SUPPORT_OPENMP)
    IF(CXXCOMPILER_SUPPORT_OPENMP)
        OPTION(ENABLE_OPENMP_GLOBALY "Enable/Disable GCC OpenMP" OFF)
        IF(ENABLE_OPENMP_GLOBALY)
            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
            MESSAGE(STATUS "Enabling OpenMP")
        ENDIF()
    ENDIF()
ELSEIF(CMAKE_CXX_COMPILER MATCHES "/icpc$" OR CMAKE_CXX_COMPILER MATCHES "/icpc.exe$")
    SET(CMAKE_AR ${XIAR})
    OPTION(ENABLE_OPENMP_GLOBALY "Enable/Disable Intel OpenMP" OFF)
    IF(ENABLE_OPENMP_GLOBALY)
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -openmp")
        IF(USE_CUDA)
            SET(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fopenmp -lgomp)
        ENDIF()
        MESSAGE(STATUS "Enabling Intel OpenMP")
    ENDIF()
    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -unroll-aggressive -parallel -fomit-frame-pointer -ipo -static -no-prec-div -xHost")
ENDIF()

INCLUDE(CTest)
IF(BUILD_TESTING)
    ADD_SUBDIRECTORY(testing)
ENDIF()

OPTION(ENABLE_EXAMPLES "Enable examples" OFF)
IF(ENABLE_EXAMPLES)
  ADD_SUBDIRECTORY(examples)
  MESSAGE(STATUS "Enabling Examples")
ENDIF()

OPTION(USE_EXAFMM "Enable ExaFMM" OFF)
IF(USE_EXAFMM)
    ADD_SUBDIRECTORY(external/exafmm)
ENDIF()

# Set documentation target
OPTION(BUILD_DOCS "Build doxygen documentation" ON)
IF(BUILD_DOCS)
    SET(EXAFMM_VERSION 0.0)
    configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
    ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    )
    ADD_CUSTOM_TARGET(docs ALL COMMAND doxygen ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
ENDIF()

# Setup host variables
option(ADD_SUBMISSION_SCRIPTS "Add custom target for job submision." OFF)