CMakeLists.txt 13.4 KB
Newer Older
1
CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8)
2 3 4 5
SET(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build,
options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release
RelWithDebInfo MinSizeRel.")

6 7
PROJECT(Nektar++ C CXX)

8 9
# Nektar++ requires C++11. Try to infer this for older CMake versions (less than
# 3.1.0)
10 11 12 13 14 15 16 17 18 19 20 21
IF ("${CMAKE_VERSION}" VERSION_LESS "3.1")
    IF (NOT MSVC)
        INCLUDE(CheckCXXCompilerFlag)
        CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

        IF (COMPILER_SUPPORTS_CXX11)
            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
        ELSE()
            MESSAGE(FATAL_ERROR "Nektar++ requires a compiler with C++11 support.")
        ENDIF()
    ELSEIF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
        MESSAGE(FATAL_ERROR "Nektar++ requires full C++11 support: please upgrade to Visual Studio 2013 or later")
22 23 24 25 26 27
    ENDIF()
ELSE()
    SET(CMAKE_CXX_STANDARD 11)
    SET(CMAKE_CXX_STANDARD_REQUIRED ON)
    SET(CMAKE_CXX_EXTENSIONS OFF)
ENDIF()
28 29 30 31 32

INCLUDE(CheckLanguage)

CHECK_LANGUAGE(Fortran)
IF(CMAKE_Fortran_COMPILER)
33
    ENABLE_LANGUAGE(Fortran)
34
ELSE()
35
    MESSAGE(STATUS "No Fortran support")
36
ENDIF()
37 38 39 40 41 42 43 44 45 46 47 48 49

# Helps organize projects in IDEs.
SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON)

# Extract the version number from the VERSION file and set in CMake
# The format of this file must be X.X.X
FILE(STRINGS "VERSION" NEKVER)
STRING(REPLACE "." ";" NEKVERLIST ${NEKVER})
LIST(GET NEKVERLIST 0 NEKTAR_VERSION_MAJOR)
LIST(GET NEKVERLIST 1 NEKTAR_VERSION_MINOR)
LIST(GET NEKVERLIST 2 NEKTAR_VERSION_PATCH)
SET(NEKTAR_VERSION ${NEKTAR_VERSION_MAJOR}.${NEKTAR_VERSION_MINOR}.${NEKTAR_VERSION_PATCH})

50
# Add support for CMAKE_DEPENDENT_OPTION
51
INCLUDE(CMakeDependentOption)
52
INCLUDE(CMakeParseArguments)
53 54

# Enable CTest.
55 56 57 58
ENABLE_TESTING()

# Use the CMake 2.4 policy for CMake 2.6
IF(COMMAND cmake_policy)
59 60 61 62 63
    # Silence warnings when using generator expressions in
    # TARGET_LINK_LIBRARIES.
    IF(POLICY CMP0022)
        CMAKE_POLICY(SET CMP0022 NEW)
    ENDIF()
64 65 66 67
ENDIF(COMMAND cmake_policy)

# Find the modules included with Nektar
SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
68 69 70 71

# Set default install path if not provided on the command-line
IF (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
    SET(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/dist CACHE PATH "" FORCE)
72 73
ENDIF()

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
# Find default search paths for OS X; adapted from Stack Overflow question
# 1487752
IF (APPLE)
    EXECUTE_PROCESS(COMMAND which port
        RESULT_VARIABLE DETECT_MACPORTS
        OUTPUT_VARIABLE MACPORTS_PREFIX
        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
    EXECUTE_PROCESS(COMMAND brew --prefix
        RESULT_VARIABLE DETECT_HOMEBREW
        OUTPUT_VARIABLE HOMEBREW_PREFIX
        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

    IF (${DETECT_MACPORTS} EQUAL 0)
        GET_FILENAME_COMPONENT(MACPORTS_PREFIX ${MACPORTS_PREFIX} DIRECTORY)
        GET_FILENAME_COMPONENT(MACPORTS_PREFIX ${MACPORTS_PREFIX} DIRECTORY)
        SET(CMAKE_LIBRARY_PATH ${MACPORTS_PREFIX}/lib ${CMAKE_LIBRARY_PATH})
        SET(CMAKE_INCLUDE_PATH ${MACPORTS_PREFIX}/include ${CMAKE_INCLUDE_PATH})
        MESSAGE(STATUS "Detected MacPorts installation: ${MACPORTS_PREFIX}")
92 93
    ELSE()
        UNSET(MACPORTS_PREFIX)
94 95 96 97 98 99
    ENDIF()

    IF (${DETECT_HOMEBREW} EQUAL 0)
        SET(CMAKE_LIBRARY_PATH ${HOMEBREW_PREFIX}/lib ${CMAKE_LIBRARY_PATH})
        SET(CMAKE_INCLUDE_PATH ${HOMEBREW_PREFIX}/include ${CMAKE_INCLUDE_PATH})
        MESSAGE(STATUS "Detected Homebrew installation: ${HOMEBREW_PREFIX}")
100 101
    ELSE()
        UNSET(HOMEBREW_PREFIX)
102
    ENDIF()
103 104 105

    UNSET(DETECT_HOMEBREW)
    UNSET(DETECT_MACPORTS)
106 107
ENDIF()

108
# Attempt to retrieve git branch and SHA1 hash of current changeset.
109
INCLUDE(GetGitRevisionDescription)
Chris Cantwell's avatar
Chris Cantwell committed
110
get_git_head_revision(GIT_REFSPEC GIT_SHA1)
111

112
# Set library, binary, include, share and doc paths.
113
SET(LIB_DIR "lib/nektar++-${NEKTAR_VERSION}")
Dave Moxey's avatar
Dave Moxey committed
114
IF( CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND NOT APPLE )
115
    SET(LIB_DIR "lib64/nektar++-${NEKTAR_VERSION}")
116 117 118 119 120
ENDIF()
SET(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ")

SET(NEKTAR_BIN_DIR bin)
SET(NEKTAR_LIB_DIR ${LIB_DIR})
121 122 123
SET(NEKTAR_INCLUDE_DIR include/nektar++-${NEKTAR_VERSION})
SET(NEKTAR_SHARE_DIR share/nektar++-${NEKTAR_VERSION})
SET(NEKTAR_DOC_DIR share/doc/nektar++-${NEKTAR_VERSION})
124 125

# Build shared libraries.
126 127 128 129 130 131
SET(NEKTAR_LIBRARY_TYPE "SHARED")

# Set up RPATH
SET(CMAKE_SKIP_BUILD_RPATH  FALSE)
SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
SET(CMAKE_INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/${LIB_DIR}")
132 133 134 135
IF (APPLE)
    SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
    SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_DIR}")
ENDIF()
136 137 138 139 140 141
LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES
	"${CMAKE_INSTALL_PREFIX}/${LIB_DIR}" isSystemDir)
IF("${isSystemDir}" STREQUAL "-1")
	SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_DIR}")
ENDIF("${isSystemDir}" STREQUAL "-1")

142 143 144 145 146 147 148
# Get rid of OS X RPATH warnings -- we should set this to 1 once we reach
# required minimum cmake version of 3.0.0 and configure it in a more sane
# fashion.
IF(NOT DEFINED CMAKE_MACOSX_RPATH)
    SET(CMAKE_MACOSX_RPATH 0)
ENDIF()

149 150 151 152 153 154 155 156
# Components of the Nektar++ package to build
OPTION(NEKTAR_BUILD_LIBRARY    "Build main Nektar++ libraries." ON)
OPTION(NEKTAR_BUILD_DEMOS      "Build demonstration codes."     ON)
OPTION(NEKTAR_BUILD_SOLVERS    "Build example solvers."         ON)
OPTION(NEKTAR_BUILD_UTILITIES  "Build utilities."               ON)
OPTION(NEKTAR_BUILD_UNIT_TESTS "Build unit tests."              ON)
OPTION(NEKTAR_BUILD_TESTS      "Build regression tests."        ON)
OPTION(NEKTAR_BUILD_TIMINGS    "Build benchmark timing codes."  OFF)
Dave Moxey's avatar
Dave Moxey committed
157
OPTION(NEKTAR_BUILD_PYTHON     "Build Nektar++ Python bindings" OFF)
158 159
OPTION(NEKTAR_BUILD_PACKAGES   "Build Nektar++ binary packages" OFF)
MARK_AS_ADVANCED(NEKTAR_BUILD_PACKAGES)
160

161
OPTION(NEKTAR_TEST_ALL "Include full set of regression tests to this build." OFF)
162 163
OPTION(NEKTAR_TEST_USE_HOSTFILE "Use a hostfile to explicitly specify number of
slots." OFF)
164

165
# Meshing utilities and library
166 167 168
IF (NOT WIN32)
    OPTION(NEKTAR_USE_MESHGEN "Build mesh generation utilities." OFF)
ENDIF()
169

170 171 172 173
# Build options
OPTION(NEKTAR_FULL_DEBUG "Enable Full Debugging." OFF)
MARK_AS_ADVANCED(NEKTAR_FULL_DEBUG)

174
IF (${CMAKE_COMPILER_IS_GNUCXX})
175 176
    OPTION(NEKTAR_ENABLE_PROFILE "Uses -pg compiler flag" OFF)
    MARK_AS_ADVANCED(NEKTAR_ENABLE_PROFILE)
177
ENDIF (${CMAKE_COMPILER_IS_GNUCXX})
178 179

# BLAS Support
180 181 182
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_SYSTEM_BLAS_LAPACK
    "Use the system provided blas and lapack libraries" ON
    "UNIX; NOT APPLE; NOT NEKTAR_USE_OPENBLAS; NOT NEKTAR_USE_MKL; NOT NEKTAR_USE_ACML; NOT NEKTAR_USE_ACCELERATE_FRAMEWORK" OFF)
183 184
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_OPENBLAS
    "Use OpenBLAS library as a substitute to native BLAS." OFF
185
    "NOT NEKTAR_USE_SYSTEM_BLAS_LAPACK" OFF)
186 187
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_ACML
    "Use the AMD Core Math Library (ACML) for BLAS and Lapack support." OFF
188
    "NOT NEKTAR_USE_SYSTEM_BLAS_LAPACK" OFF)
189 190
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_MKL
    "Use the Intel Math Kernel Library (MKL) for BLAS and Lapack support." OFF
191
    "NOT NEKTAR_USE_SYSTEM_BLAS_LAPACK" OFF)
192 193
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_ACCELERATE_FRAMEWORK
    "Use the Mac Accelerate Framework for BLAS and Lapack support." ON
194
    "NOT NEKTAR_USE_SYSTEM_BLAS_LAPACK; APPLE" OFF)
195 196
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_WIN32_LAPACK
    "Use Win32 Lapack provided with the Third Party Distribution."
197
    ON "NOT NEKTAR_USE_SYSTEM_BLAS_LAPACK; WIN32" OFF)
198

Dave Moxey's avatar
Dave Moxey committed
199
# Memory pools
200 201 202 203
OPTION(NEKTAR_USE_MEMORY_POOLS
    "Use memory pools to accelerate memory allocation." ON)
MARK_AS_ADVANCED(NEKTAR_USE_MEMORY_POOLS)

204 205 206
IF (MSVC)
    # Needed for M_PI to be visible in visual studio.
    ADD_DEFINITIONS(-D_USE_MATH_DEFINES)
207

208
    # Removes the warnings about unsafe methods such as strcpy, std::copy,
209
    # memcmp, etc.
210 211
    ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_DEPRECATE)
ENDIF()
212

213 214
# Add option to use Python 3.
CMAKE_DEPENDENT_OPTION(NEKTAR_USE_PYTHON3
215
    "If true, prefer to use Python 3." OFF "NEKTAR_BUILD_PYTHON" OFF)
216 217

IF (NEKTAR_BUILD_PYTHON)
218 219 220 221 222 223 224
    # Unset any existing python executable/library settings so that
    # we can rediscover correct python version if v2/3 settings changed
    unset(PYTHON_EXECUTABLE CACHE)
    unset(PYTHON_INCLUDE_DIR CACHE)
    unset(PYTHON_LIBRARY CACHE)
    unset(PYTHON_LIBRARY_DEBUG CACHE)

225 226
    SET(PYTHONVER 2.7)
    IF (NEKTAR_USE_PYTHON3)
227
        SET(PYTHONVER 3.0)
228 229 230 231
    ENDIF()

    # Find Python
    FIND_PACKAGE(PythonInterp  ${PYTHONVER} REQUIRED)
232
    FIND_PACKAGE(PythonLibsNew ${PYTHONVER} REQUIRED)
233 234 235
    INCLUDE_DIRECTORIES(SYSTEM ${PYTHON_INCLUDE_DIRS})
ENDIF()

236 237 238
# Include Nektar++ common macros
INCLUDE (NektarCommon)

239
# Set various ThirdParty locations
240 241 242 243 244 245 246
OPTION(THIRDPARTY_USE_SSL "Use secure HTTP connection to download third-party files." OFF)
IF (THIRDPARTY_USE_SSL)
    SET(TPURL https://www.nektar.info/thirdparty)
ELSE()
    SET(TPURL http://www.nektar.info/thirdparty)
ENDIF()

247
SET(TPSRC   ${CMAKE_SOURCE_DIR}/ThirdParty)
248
SET(TPBUILD ${CMAKE_BINARY_DIR}/ThirdParty)
249
SET(TPDIST  ${CMAKE_BINARY_DIR}/ThirdParty/dist)
250
SET(TPINC   ${CMAKE_INSTALL_PREFIX}/include/ThirdParty)
251
SET(TPLIB   ${CMAKE_INSTALL_PREFIX}/${NEKTAR_LIB_DIR})
252 253

# Create ThirdParty source directory if it doesn't exist already.
254 255 256
IF (NOT EXISTS ${TPSRC})
    FILE(MAKE_DIRECTORY ${TPSRC})
ENDIF ()
257

258
# Find ThirdParty libraries and headers.
259 260
INCLUDE (ThirdPartyTinyxml)
INCLUDE (ThirdPartyMetis)
261
INCLUDE (ThirdPartyHDF5)
262
INCLUDE (ThirdPartyScotch)
263
INCLUDE (ThirdPartyZlib)
264
INCLUDE (ThirdPartyBoost)
265 266 267 268
INCLUDE (ThirdPartyFFTW)
INCLUDE (ThirdPartyArpack)
INCLUDE (ThirdPartyMPI)
INCLUDE (ThirdPartyVTK)
Michael Turner's avatar
Michael Turner committed
269
INCLUDE (ThirdPartyOCE)
Michael Turner's avatar
Michael Turner committed
270
INCLUDE (ThirdPartyTriangle)
Michael Turner's avatar
Michael Turner committed
271
INCLUDE (ThirdPartyTetGen)
272
INCLUDE (ThirdPartyCCM)
273
INCLUDE (ThirdPartyPython)
Michael Turner's avatar
Michael Turner committed
274
INCLUDE (FindCFI)
275

276 277
INCLUDE (Doxygen)

278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
IF( NEKTAR_USE_MKL )
    INCLUDE (FindMKL)
ENDIF( NEKTAR_USE_MKL )

IF( NEKTAR_USE_OPENBLAS )
    INCLUDE (FindOpenBlas)
ENDIF( NEKTAR_USE_OPENBLAS )

IF( NEKTAR_USE_ACCELERATE_FRAMEWORK )
    INCLUDE (FindAccelerateFramework)
ENDIF( NEKTAR_USE_ACCELERATE_FRAMEWORK )

IF( NEKTAR_USE_ACML )
    INCLUDE (FindACML)
ENDIF( NEKTAR_USE_ACML )

IF( NEKTAR_USE_WIN32_LAPACK )
    INCLUDE (FindWin32Lapack)
ENDIF( NEKTAR_USE_WIN32_LAPACK )

IF( NEKTAR_USE_SYSTEM_BLAS_LAPACK )
Michael Turner's avatar
Michael Turner committed
299
    INCLUDE(ThirdPartyBlasLapack)
300 301 302 303 304 305 306 307 308 309 310 311
ENDIF( NEKTAR_USE_SYSTEM_BLAS_LAPACK )

IF( NEKTAR_USE_TINYXML_STL )
    ADD_DEFINITIONS( -DTIXML_USE_STL)
ENDIF( NEKTAR_USE_TINYXML_STL )

IF( NEKTAR_USE_MEMORY_POOLS )
    ADD_DEFINITIONS(-DNEKTAR_MEMORY_POOL_ENABLED)
ELSE( NEKTAR_USE_MEMORY_POOLS )
    REMOVE_DEFINITIONS(-DNEKTAR_MEMORY_POOL_ENABLED)
ENDIF( NEKTAR_USE_MEMORY_POOLS )

Kilian Lackhove's avatar
Kilian Lackhove committed
312 313
INCLUDE (ThirdPartyPETSc)

314 315 316 317 318 319 320 321 322 323 324 325 326
SET(Boost_USE_STATIC_LIBS OFF)
IF( WIN32 )
    # The auto-linking feature has problems with USE_STATIC_LIBS off, so we use
    # BOOST_ALL_NO_LIB to turn it off.
    # Several boost libraries headers aren't configured correctly if
    # USE_STATIC_LIBS is off, so we explicitly say they are dynamic with the
    # remaining definitions.
    ADD_DEFINITIONS(-DBOOST_ALL_NO_LIB -DBOOST_PROGRAM_OPTIONS_DYN_LINK -DBOOST_IOSTREAMS_DYN_LINK -DBOOST_THREAD_DYN_LINK)
ENDIF( )

# Set up include directories. Include work-around for -isystem for CMake (see
# bug 0010837) to avoid unnecessary compiler warnings for third-party libs.
IF (APPLE)
327 328
  SET(CMAKE_INCLUDE_SYSTEM_FLAG_C   "-isystem ")
  SET(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-isystem ")
329 330 331 332
ENDIF (APPLE)

INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR})

333 334
# Build active components. Add utilities and solvers directories first, because
# that allows us to detect library dependencies automatically.
335 336
IF (NEKTAR_BUILD_LIBRARY)
    INCLUDE_DIRECTORIES(library)
337 338
ENDIF()

339 340 341 342 343 344
INCLUDE_DIRECTORIES(utilities)
ADD_SUBDIRECTORY(utilities)

INCLUDE_DIRECTORIES(solvers)
ADD_SUBDIRECTORY(solvers)

345
IF (NEKTAR_BUILD_LIBRARY)
346 347 348
    # List of Nektar++ libraries will be rebuilt every configuration.
    SET(NEKTAR++_LIBRARIES "" CACHE INTERNAL "")

349
    ADD_SUBDIRECTORY(library)
350
    INSTALL(EXPORT Nektar++Libraries DESTINATION ${LIB_DIR}/cmake COMPONENT dev)
351 352 353 354 355
ENDIF (NEKTAR_BUILD_LIBRARY)

IF (NEKTAR_BUILD_TESTS)
    INCLUDE_DIRECTORIES(tests)
    ADD_SUBDIRECTORY(tests)
356 357 358
    IF (NEKTAR_USE_MPI)
        OPTION(NEKTAR_TEST_FORCEMPIEXEC  "Force all tests to be run through the MPI job launcher."  OFF)
    ENDIF (NEKTAR_USE_MPI)
359 360
ENDIF (NEKTAR_BUILD_TESTS)

361 362
# Compile list of definitions for Nektar++Config.cmake input file. We exclude
# vtk definitions which should not be required for external builds.
363 364 365 366
SET(NEKTAR_DEFINITIONS "")
GET_DIRECTORY_PROPERTY(
    NEKTAR_DEFINITIONS_LIST DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS)
FOREACH(def ${NEKTAR_DEFINITIONS_LIST})
367 368 369
    IF (NOT def MATCHES "^vtk")
        SET(NEKTAR_DEFINITIONS "${NEKTAR_DEFINITIONS} -D${def}")
    ENDIF()
370 371
ENDFOREACH()

372 373
# Write out Nektar++ build configuration
CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/cmake/Nektar++Config.cmake.in
374
               ${CMAKE_BINARY_DIR}/Nektar++Config.cmake @ONLY)
375 376 377

# Install Nektar++ CMake configuration file
INSTALL(FILES ${CMAKE_BINARY_DIR}/Nektar++Config.cmake
378 379
    DESTINATION ${NEKTAR_LIB_DIR}/cmake/
    COMPONENT dev)
380 381

# Install ThirdParty headers to subdirectory of ${NEKTAR_INCLUDE_DIR}
382 383 384 385 386 387
IF (EXISTS ${TPDIST}/include)
    INSTALL(DIRECTORY ${TPDIST}/include/
        DESTINATION ${NEKTAR_INCLUDE_DIR}/ThirdParty
        COMPONENT dev
        )
ENDIF()
388

Dave Moxey's avatar
Dave Moxey committed
389 390
# Install ThirdParty libraries into ${NEKTAR_LIB_DIR}. These are shipped with
# the LibUtilities library.
391 392 393 394 395 396
IF (EXISTS ${TPDIST}/lib)
    INSTALL(DIRECTORY ${TPDIST}/lib/
        DESTINATION ${NEKTAR_LIB_DIR}
        COMPONENT libutilities
        )
ENDIF()
397

398
ADD_SUBDIRECTORY(docs)
399

400
IF(NEKTAR_BUILD_PACKAGES)
Dave Moxey's avatar
Dave Moxey committed
401
    ADD_SUBDIRECTORY(pkg)
402
ENDIF(NEKTAR_BUILD_PACKAGES)