CMakeLists.txt

   1 #-------------------------------------------------------------------------------
   2 #               ______                _     ____          __  __
   3 #              |  ____|             _| |_  / __ \   /\   |  \/  |
   4 #              | |__ _ __ ___  ___ /     \| |  | | /  \  | \  / |
   5 #              |  __| '__/ _ \/ _ ( (| |) ) |  | |/ /\ \ | |\/| |
   6 #              | |  | | |  __/  __/\_   _/| |__| / ____ \| |  | |
   7 #              |_|  |_|  \___|\___|  |_|   \____/_/    \_\_|  |_|
   8 #
   9 #                   FreeFOAM: The Cross-Platform CFD Toolkit
  10 #
  11 # Copyright (C) 2008-2012 Michael Wild <themiwi@users.sf.net>
  12 #                         Gerber van der Graaf <gerber_graaf@users.sf.net>
  13 #-------------------------------------------------------------------------------
  14 # License
  15 #   This file is part of FreeFOAM.
  16 #
  17 #   FreeFOAM is free software: you can redistribute it and/or modify it
  18 #   under the terms of the GNU General Public License as published by the
  19 #   Free Software Foundation, either version 3 of the License, or (at your
  20 #   option) any later version.
  21 #
  22 #   FreeFOAM is distributed in the hope that it will be useful, but WITHOUT
  23 #   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  24 #   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  25 #   for more details.
  26 #
  27 #   You should have received a copy of the GNU General Public License
  28 #   along with FreeFOAM.  If not, see <http://www.gnu.org/licenses/>.
  29 #-------------------------------------------------------------------------------
  30
  31 cmake_minimum_required(VERSION 2.8.2 FATAL_ERROR)
  32
  33 project(FreeFOAM)
  34
  35 string(TOLOWER "${PROJECT_NAME}" LOWER_PROJECT_NAME)
  36
  37 # version information
  38 set(FOAM_VERSION_MAJOR 0)
  39 set(FOAM_VERSION_MINOR 1)
  40 set(FOAM_VERSION_PATCH 0)
  41 set(FOAM_VERSION_SUFFIX)
  42 set(FOAM_VERSION ${FOAM_VERSION_MAJOR}.${FOAM_VERSION_MINOR})
  43 set(FOAM_VERSION_FULL
  44   ${FOAM_VERSION}.${FOAM_VERSION_PATCH}${FOAM_VERSION_SUFFIX})
  45 set(FOAM_SOVERSION 1)
  46 set(FOAM_UPSTREAM_VERSION_FULL 1.7.x-d08d3c2)
  47
  48 # set up custom cmake module path
  49 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMake/Modules)
  50
  51 # utilities
  52 set(FOAM_CREATE_INCLUDE_WRAPPERS TRUE)
  53 set(FOAM_HAS_FLEX_SOURCES TRUE)
  54 set(FOAM_ENABLE_DOC_INDEX TRUE)
  55 set(FOAM_EXPORT_NAMESPACE FOAM_)
  56 include(${CMAKE_SOURCE_DIR}/CMake/FOAMUtilities.cmake)
  57 include(${CMAKE_SOURCE_DIR}/CMake/FOAMThirdPartyUtilities.cmake)
  58 include(${CMAKE_SOURCE_DIR}/CMake/FOAMInternal.cmake)
  59 include(CTest)
  60
  61 # determine computer system
  62 include(${CMAKE_SOURCE_DIR}/CMake/FOAMDetermineArch.cmake)
  63
  64 # select precision
  65 foam_option(FOAM_DOUBLE_PRECISION "Double precision"
  66   "Compile ${PROJECT_NAME} with double precision floating point arithmetics."
  67   ON)
  68 mark_as_advanced(FOAM_DOUBLE_PRECISION)
  69 if(FOAM_DOUBLE_PRECISION)
  70   set(FOAM_PRECISION DP)
  71 else()
  72   set(FOAM_PRECISION SP)
  73 endif()
  74
  75 # select whether we want to build framewors on Mac OS X
  76 if(APPLE)
  77   foam_option(FOAM_BUILD_FRAMEWORKS "Build frameworks"
  78     "Build frameworks on Mac OS X" OFF)
  79   mark_as_advanced(FOAM_BUILD_FRAMEWORKS)
  80 else()
  81   set(FOAM_BUILD_FRAMEWORKS OFF)
  82 endif()
  83
  84 # find python interpreter
  85 find_package(PythonInterp REQUIRED)
  86
  87 # make sure we got Python version 2.4 or newer
  88 foam_dependent_variables(PYTHON_EXECUTABLE PYTHON_VERSION)
  89 if(NOT PYTHON_VERSION)
  90   foam_determine_python_version(PYTHON_VERSION ${PYTHON_EXECUTABLE})
  91   set(PYTHON_VERSION ${PYTHON_VERSION} CACHE INTERNAL "The Python version")
  92   if(PYTHON_VERSION VERSION_LESS 2.4.0)
  93     message(SEND_ERROR
  94       "Python version 2.4 or newer required (PYTHON_EXECUTABLE)")
  95   endif()
  96 endif()
  97 string(REGEX REPLACE "\\.[0-9]+$" "" PYTHON_SHORT_VERSION ${PYTHON_VERSION})
  98
  99 # find the installed ParaView executable
 100 find_program(
 101   FOAM_PARAVIEW3_APP NAMES "ParaView 3.12.0" "ParaView 3.10.1"
 102   "ParaView 3.10.0" "ParaView 3.8.1" "ParaView 3.8.0" ParaView paraview
 103   DOC "Path to the ParaView 3.8 (or newer) application")
 104 mark_as_advanced(FOAM_PARAVIEW3_APP)
 105 foam_dependent_variables(FOAM_PARAVIEW3_APP FOAM_PARAVIEW3_VERSION)
 106 if(FOAM_PARAVIEW3_APP)
 107   if(NOT FOAM_PARAVIEW3_VERSION)
 108     get_filename_component(_FOAM_PV3_BINDIR ${FOAM_PARAVIEW3_APP} PATH)
 109     set(_FOAM_PVBATCH_EXECUTABLE ${_FOAM_PV3_BINDIR}/pvbatch)
 110     if(NOT EXISTS ${_FOAM_PVBATCH_EXECUTABLE})
 111       set(_FOAM_PVBATCH_EXECUTABLE ${FOAM_PARAVIEW3_APP})
 112     endif()
 113     execute_process(COMMAND ${_FOAM_PVBATCH_EXECUTABLE} --version
 114       OUTPUT_VARIABLE _pv_version_output
 115       ERROR_VARIABLE _pv_version_output
 116       OUTPUT_STRIP_TRAILING_WHITESPACE
 117       )
 118     if(_pv_version_output MATCHES
 119         "(paraview version |ParaView)(([0-9]+\\.)+[0-9]+)")
 120       set(FOAM_PARAVIEW3_VERSION ${CMAKE_MATCH_2} CACHE INTERNAL
 121         "The ParaView version")
 122       message(STATUS
 123         "ParaView ${FOAM_PARAVIEW3_VERSION} found: ${FOAM_PARAVIEW3_APP}")
 124     else()
 125       message(SEND_ERROR
 126         "Failed to determine the ParaView version: ${_pv_version_output}")
 127     endif()
 128   endif()
 129   if(${FOAM_PARAVIEW3_VERSION} VERSION_LESS 3.8)
 130     message(WARNING
 131       "ParaView versions older than 3.8 might not be able\n"
 132       "to read ${PROJECT_NAME} cases.")
 133   endif()
 134 else()
 135   message(WARNING
 136     "Failed to find the ParaView application")
 137   set(FOAM_PARAVIEW3_APP)
 138 endif()
 139
 140 # we want shared libraries
 141 set(BUILD_SHARED_LIBS SHARED)
 142
 143 # installation directories
 144 foam_installation_path(FOAM_INSTALL_BIN_PATH bin "Executables"
 145   "Executables installation path")
 146 if(APPLE AND FOAM_BUILD_FRAMEWORKS)
 147   foam_installation_path(FOAM_INSTALL_FRAMEWORK_PATH /Library/Frameworks
 148     "Frameworks" "Framework installation path")
 149 endif()
 150 foam_installation_path(FOAM_INSTALL_LIBRARY_PATH
 151   lib/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL}
 152   "Libraries" "Library installation path")
 153 if(NOT WIN32)
 154   foam_installation_path(FOAM_INSTALL_PLUGIN_PATH
 155     "${FOAM_INSTALL_LIBRARY_PATH_ORIG}/plugins${FOAM_SOVERSION}"
 156     "Plugins" "Plugin installation path")
 157 endif()
 158 foam_installation_path(FOAM_INSTALL_LIBEXEC_PATH
 159   libexec/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL} "Private executables"
 160   "Installation path for executables not on PATH.")
 161 foam_installation_path(FOAM_INSTALL_HEADER_PATH
 162   include/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL}
 163   "Headers" "Header installation path (not for frameworks)")
 164 foam_installation_path(FOAM_INSTALL_CONFIG_PATH
 165   etc/${CMAKE_PROJECT_NAME}/${FOAM_VERSION_FULL} "Config files"
 166   "Configuration files installation path")
 167 foam_installation_path(FOAM_INSTALL_DATA_PATH
 168   share/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL} "Data files"
 169   "Data files installation path")
 170 foam_installation_path(FOAM_INSTALL_DOC_PATH
 171   share/doc/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL} "Documentation"
 172   "Documentation files installation path")
 173 foam_installation_path(FOAM_INSTALL_MAN_PATH share/man "Man pages"
 174   "Man-pages installation path")
 175 foam_installation_path(FOAM_INSTALL_TUTORIALS_PATH
 176   "${FOAM_INSTALL_DOC_PATH_ORIG}" "Tutorials" "Tutorials installation path")
 177 foam_installation_path(FOAM_INSTALL_CMAKE_PATH
 178   "${FOAM_INSTALL_DATA_PATH_ORIG}/CMake"
 179   "CMake files" "CMake configuration files installation path")
 180 foam_installation_path(FOAM_INSTALL_USERDFOAM_PATH
 181   "${FOAM_INSTALL_PLUGIN_PATH_ORIG}/ensightReader"
 182   "Ensight plugin" "Ensight OpenFOAM-reader plugin installation path")
 183 foam_dependent_variables(PYTHON_VERSION FOAM_INSTALL_PYTHON_PATH)
 184 foam_installation_path(FOAM_INSTALL_PYTHON_PATH
 185   "lib/python${PYTHON_SHORT_VERSION}/site-packages"
 186   "Python modules" "Python modules installation base path")
 187
 188 set(FOAM_INSTALL_RUNTIME_PATH "${FOAM_INSTALL_LIBEXEC_PATH}")
 189
 190 # determine the INSTALL_NAME_DIR of potential frameworks
 191 if(APPLE AND FOAM_BUILD_FRAMEWORKS)
 192   set(FOAM_FRAMEWORK_INSTALL_NAME_DIR "${FOAM_INSTALL_FRAMEWORK_PATH}")
 193 else()
 194   set(FOAM_FRAMEWORK_INSTALL_NAME_DIR "${FOAM_INSTALL_LIBRARY_PATH}")
 195 endif()
 196
 197 # select html documentation browser (try a few well known ones for default)
 198 # have to loop, because find_program(HTML_DOC_BROWSER NAMES ...) garbles things
 199 # up
 200 set(_BROWSERS xdg-open sensible-browser x-www-browser gnome-open kde-open
 201   firefox chromium-browser epiphany konqueror www-browser w3m lynx launch)
 202 if(APPLE)
 203   list(INSERT _BROWSERS 0 open)
 204 endif()
 205 foreach(browser IN LISTS _BROWSERS)
 206   find_program(HTML_DOC_BROWSER ${browser}
 207     DOC "Program to open an HTML file")
 208   if(HTML_DOC_BROWSER)
 209     break()
 210   endif()
 211 endforeach()
 212 if(NOT HTML_DOC_BROWSER)
 213   message(STATUS
 214     "Failed to find a program to open HTML pages with (a.k.a a browser).\n"
 215     "Point HTML_DOC_BROWSER to a suitable program.")
 216   set(HTML_DOC_BROWSER "ECHO" CACHE STRING
 217     "Command to open an HTML file (ECHO will print it to STDOUT)" FORCE)
 218 endif()
 219 set(FOAM_HTML_DOC_BROWSER_COMMAND
 220   "\${HTML_DOC_BROWSER} %f" CACHE STRING "Command to open an HTML file")
 221 string(CONFIGURE "${FOAM_HTML_DOC_BROWSER_COMMAND}"
 222   FOAM_HTML_DOC_BROWSER_COMMAND ESCAPE_QUOTES)
 223 mark_as_advanced(HTML_DOC_BROWSER FOAM_HTML_DOC_BROWSER_COMMAND)
 224
 225 # Executable-prefix
 226 string(TOLOWER "${PROJECT_NAME}-" _FOAM_DEFAULT_EXE_PREFIX)
 227 set(FOAM_EXE_PREFIX "${_FOAM_DEFAULT_EXE_PREFIX}"
 228   CACHE STRING "Prefix for application output-names")
 229 mark_as_advanced(FOAM_EXE_PREFIX)
 230 string(TOUPPER "${FOAM_EXE_PREFIX}" FOAM_UPPER_EXE_PREFIX)
 231
 232 # ask user whether she wants to build Doxygen docs
 233 foam_option(FOAM_ENABLE_DOXYGEN_DOCS "Doxygen API documentation"
 234   "Build the Doxygen API documentation" OFF)
 235 # make sure only ON and OFF are used
 236 if(FOAM_ENABLE_DOXYGEN_DOCS)
 237   set(FOAM_ENABLE_DOXYGEN_DOCS ON)
 238 else()
 239   set(FOAM_ENABLE_DOXYGEN_DOCS OFF)
 240 endif()
 241 # if user wants doxygen docs, find Doxygen and set up some options
 242 if(FOAM_ENABLE_DOXYGEN_DOCS)
 243   find_package(Doxygen REQUIRED)
 244   execute_process(COMMAND ${DOXYGEN_EXECUTABLE} --version
 245     RESULT_VARIABLE DOXYGEN_VERSION_RESULT
 246     OUTPUT_VARIABLE DOXYGEN_VERSION_OUTPUT
 247     OUTPUT_STRIP_TRAILING_WHITESPACE)
 248   if(DOXYGEN_VERSION_RESULT)
 249     message(SEND_ERROR "Failed to determine doxygen version")
 250   endif()
 251   if(${DOXYGEN_VERSION_OUTPUT} VERSION_GREATER 1.6.3 AND
 252       ${DOXYGEN_VERSION_OUTPUT} VERSION_LESS 1.7.2-20101106)
 253     message(WARNING
 254       "Found Doxygen version ${DOXYGEN_VERSION_OUTPUT}. "
 255       "Versions newer than 1.6.3 and older than 1.7.2-20101106 "
 256       "usually crash when processing the ${PROJECT_NAME} documentation.")
 257   endif()
 258   # ask user whether she prefers local or www docs
 259   foam_option(FOAM_USE_LOCAL_DOXYGEN_DOCS "Use local API docs"
 260     "Use the local API documentation instead of http://freefoam.sf.net/doc/API"
 261     ON)
 262   mark_as_advanced(FOAM_USE_LOCAL_DOXYGEN_DOCS)
 263 endif()
 264
 265 # ask user whether she wants to build the man pages
 266 foam_option(FOAM_ENABLE_MANPAGE_HELP "Build manpage help"
 267   "Build the manpages (requires asciidoc)" OFF)
 268 # ask user whether she wants to build the xhtml man pages
 269 foam_option(FOAM_ENABLE_XHTML_HELP "Build xhtml help"
 270   "Build the xhtml help pages (requires asciidoc)" OFF)
 271 # as user whether she wanst to build the xhtml guides
 272 foam_option(FOAM_ENABLE_XHTML_GUIDES "Build the xhtml guides"
 273   "Build the xhtml guides (requires asciidoc, dot, inkscape and asymptote)"
 274   OFF)
 275 # as user whether she wanst to build the xhtml guides
 276 foam_option(FOAM_ENABLE_PDF_GUIDES "Build the PDF guides"
 277   "Build the PDF guides (requires asciidoc, dot, inkscape and asymptote)" OFF)
 278 if(FOAM_ENABLE_PDF_GUIDES)
 279   foam_option(FOAM_USE_FOP "Use FOP instead of dblatex"
 280     "Use FOP to build the PDF guides instead of dblatex" OFF)
 281   mark_as_advanced(FOAM_USE_FOP)
 282 else()
 283   set(FOAM_USE_FOP FALSE)
 284 endif()
 285
 286 if(FOAM_ENABLE_DOXYGEN_DOCS OR FOAM_ENABLE_XHTML_GUIDES)
 287   foam_option(FOAM_DOCS_FOR_SF "Docs for SourceForge"
 288     "Build the docs for deployment on SourceForge" OFF)
 289   mark_as_advanced(FOAM_DOCS_FOR_SF)
 290   # make sure only ON and OFF are used
 291   if(FOAM_DOCS_FOR_SF)
 292     set(FOAM_DOCS_FOR_SF ON)
 293   else()
 294     set(FOAM_DOCS_FOR_SF OFF)
 295   endif()
 296 endif()
 297
 298 if(BUILD_TESTING)
 299   # ask user whether whe wants full tutorial tests
 300   foam_option(FOAM_ENABLE_FULL_TUTORIAL_TESTS
 301     "Full tutorial tests"
 302     "Run the complete tutorial tests (not just a single time step)" OFF)
 303   mark_as_advanced(FOAM_ENABLE_FULL_TUTORIAL_TESTS)
 304 endif()
 305
 306 if(FOAM_ENABLE_XHTML_GUIDES)
 307   set(FOAM_ENABLE_XHTML_GUIDES ON)
 308   foam_option(FOAM_ENABLE_MATHJAX "Use MathJax in XHTML guides"
 309     "Use MathJax for formulas in the XHTML version of the guides" ON)
 310   if(FOAM_ENABLE_MATHJAX)
 311     foam_option(FOAM_MATHJAX_USE_CDN
 312       "Use the MathJax CDN"
 313       "Use public MathJax installation at http://cdn.mathjax.org" ON)
 314     mark_as_advanced(FOAM_MATHJAX_USE_CDN)
 315     if(FOAM_MATHJAX_USE_CDN)
 316       set(FOAM_MATHJAX_URL "http://cdn.mathjax.org/mathjax/latest")
 317     else()
 318       set(FOAM_MATHJAX_URL "MathJAX-NOTFOUND" CACHE PATH
 319         "Path or URL to the MathJax directory containing the MathJax.js file")
 320       mark_as_advanced(FOAM_MATHJAX_URL)
 321       if(NOT FOAM_MATHJAX_URL)
 322         message(SEND_ERROR "FOAM_MATHJAX_URL must be set to the directory or "
 323           "URL containing MathJax.js")
 324       endif()
 325     endif()
 326   endif()
 327 else()
 328   set(FOAM_ENABLE_XHTML_GUIDES OFF)
 329   set(FOAM_ENABLE_MATHJAX FALSE)
 330 endif()
 331
 332 # assemble the list of enabled manpage formats
 333 set(FOAM_MANPAGE_FORMATS)
 334 if(FOAM_ENABLE_MANPAGE_HELP)
 335   list(APPEND FOAM_MANPAGE_FORMATS manpage)
 336 endif()
 337 if(FOAM_ENABLE_XHTML_HELP)
 338   list(APPEND FOAM_MANPAGE_FORMATS xhtml)
 339 endif()
 340
 341 # assemble the list of enabled guides formats
 342 set(FOAM_GUIDES_FORMATS)
 343 if(FOAM_ENABLE_XHTML_GUIDES)
 344   list(APPEND FOAM_GUIDES_FORMATS xhtml)
 345 endif()
 346 if(FOAM_ENABLE_PDF_GUIDES)
 347   list(APPEND FOAM_GUIDES_FORMATS pdf)
 348 endif()
 349
 350 if(FOAM_MANPAGE_FORMATS OR FOAM_GUIDES_FORMATS)
 351   # find AsciiDoc
 352   find_program(ASCIIDOC_EXECUTABLE NAMES asciidoc.py asciidoc)
 353   get_filename_component(asciidoc_path "${ASCIIDOC_EXECUTABLE}" PATH)
 354   find_program(A2X_EXECUTABLE NAMES a2x.py a2x HINTS "${asciidoc_path}")
 355   if(NOT ASCIIDOC_EXECUTABLE OR NOT A2X_EXECUTABLE)
 356     message(SEND_ERROR
 357       "AsciiDoc is required to create man and html help and the guides")
 358   endif()
 359   mark_as_advanced(ASCIIDOC_EXECUTABLE A2X_EXECUTABLE)
 360   # read CONF_DIR from A2X_EXECUTABLE and copy style files over
 361   if(A2X_EXECUTABLE)
 362     file(READ "${A2X_EXECUTABLE}" _asciidoc_text)
 363     if(_asciidoc_text MATCHES "[ \t]*CONF_DIR[ \t]*=[ \t]*r?['\"]([^'\"]+)")
 364       set(A2X_CONF_DIR "${CMAKE_MATCH_1}")
 365       if(IS_DIRECTORY "${A2X_CONF_DIR}")
 366         configure_file("${A2X_CONF_DIR}/docbook-xsl/common.xsl"
 367           "${CMAKE_BINARY_DIR}/data/asciidoc/docbook-xsl/orig-common.xsl"
 368           COPYONLY)
 369         configure_file("${A2X_CONF_DIR}/docbook-xsl/chunked.xsl"
 370           "${CMAKE_BINARY_DIR}/data/asciidoc/docbook-xsl/orig-chunked.xsl"
 371           COPYONLY)
 372         configure_file("${A2X_CONF_DIR}/docbook-xsl/xhtml.xsl"
 373           "${CMAKE_BINARY_DIR}/data/asciidoc/docbook-xsl/orig-xhtml.xsl"
 374           COPYONLY)
 375         configure_file("${A2X_CONF_DIR}/dblatex/asciidoc-dblatex.sty"
 376           "${CMAKE_BINARY_DIR}/data/asciidoc/dblatex/orig-asciidoc-dblatex.sty"
 377           COPYONLY)
 378         configure_file("${A2X_CONF_DIR}/dblatex/asciidoc-dblatex.xsl"
 379           "${CMAKE_BINARY_DIR}/data/asciidoc/dblatex/orig-asciidoc-dblatex.xsl"
 380           COPYONLY)
 381       else()
 382         message(SEND_ERROR "The Asciidoc configuration directory "
 383           "${A2X_CONF_DIR} does not exist")
 384       endif()
 385     else()
 386       message(SEND_ERROR "Failed to read CONF_DIR from ${A2X_EXECUTABLE}")
 387     endif()
 388   endif()
 389   if(FOAM_ENABLE_XHTML_GUIDES)
 390     find_program(XSLTPROC_EXECUTABLE xsltproc)
 391     if(NOT XSLTPROC_EXECUTABLE)
 392       message(SEND_ERROR "Failed to find xsltproc executable"
 393         "Required if FOAM_ENABLE_XHTML_GUIDES is enabled")
 394     endif()
 395     mark_as_advanced(XSLTPROC_EXECUTABLE)
 396   endif()
 397   set(FOAM_NEED_PNGMATH FALSE)
 398   if((FOAM_ENABLE_XHTML_GUIDES AND NOT FOAM_ENABLE_MATHJAX) OR
 399     (FOAM_ENABLE_PDF_GUIES AND FOAM_USE_FOP))
 400     set(FOAM_NEED_PNGMATH TRUE)
 401     foreach(prog latex dvipng)
 402       string(TOUPPER ${prog} uprog)
 403       find_program(${uprog}_EXECUTABLE ${prog})
 404       mark_as_advanced(${uprog}_EXECUTABLE)
 405       if(NOT ${uprog}_EXECUTABLE)
 406         message(SEND_ERROR
 407           "${prog} is required when FOAM_ENABLE_MATHJAX is disabled "
 408           "or FOAM_USE_FOP is enabled")
 409       endif()
 410     endforeach()
 411   endif()
 412   if(NOT PYTHON_VERSION VERSION_LESS 3)
 413     if(NOT PYTHON2_EXECUTABLE OR NOT PYTHON2_VERSION)
 414       foam_dependent_variables(PYTHON2_EXECUTABLE PYTHON2_VERSION)
 415       find_program(PYTHON2_EXECUTABLE NAMES python2.7 python2.6 python2.5
 416         python2.4 python)
 417       if(PYTHON2_EXECUTABLE)
 418         foam_determine_python_version(PYTHON2_VERSION ${PYTHON2_EXECUTABLE})
 419         set(PYTHON2_VERSION ${PYTHON2_VERSION} CACHE INTERNAL
 420           "The Python-2 version")
 421         if(PYTHON2_VERSION VERSION_LESS 2.4 OR
 422             NOT PYTHON2_VERSION VERSION_LESS 3)
 423           message(SEND_ERROR
 424             "Python version >= 2.4 and < 3 required (PYTHON2_EXECUTABLE)")
 425         endif()
 426       else()
 427         message(SEND_ERROR
 428           "Failed to find Python-2 required for AsciiDoc (PYTHON2_EXECUTABLE)")
 429       endif()
 430     endif()
 431   else()
 432     set(PYTHON2_EXECUTABLE ${PYTHON_EXECUTABLE})
 433   endif()
 434 endif()
 435 if(FOAM_GUIDES_FORMATS)
 436   # find asymptote
 437   find_program(ASY_EXECUTABLE asy)
 438   if(NOT ASY_EXECUTABLE)
 439     message(SEND_ERROR "Asymptote is required to create the guides")
 440   endif()
 441   mark_as_advanced(ASY_EXECUTABLE)
 442 endif()
 443
 444 # set up the RPATH for installation
 445 set(CMAKE_INSTALL_RPATH ${FOAM_INSTALL_LIBRARY_PATH})
 446 set(CMAKE_INSTALL_NAME_DIR ${FOAM_FRAMEWORK_INSTALL_NAME_DIR})
 447
 448 # we want executables and libraries in uniform places
 449 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
 450   "${CMAKE_BINARY_DIR}/libexec/${PROJECT_NAME}/${FOAM_VERSION_FULL}")
 451 set(FOAM_LIBRARY_OUTPUT_DIRECTORY
 452   "${CMAKE_BINARY_DIR}/lib/${PROJECT_NAME}-${FOAM_VERSION_FULL}")
 453 set(FOAM_FRAMEWORK_OUTPUT_DIRECTORY
 454   "${CMAKE_BINARY_DIR}/Library/Frameworks")
 455 if(FOAM_BUILD_FRAMEWORKS)
 456   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${FOAM_FRAMEWORK_OUTPUT_DIRECTORY}")
 457 else()
 458   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${FOAM_LIBRARY_OUTPUT_DIRECTORY}")
 459 endif()
 460 set(FOAM_ARCHIVE_OUTPUT_DIRECTORY "${FOAM_LIBRARY_OUTPUT_DIRECTORY}")
 461
 462 # find parallel libraries
 463 find_package(MPI)
 464 if(MPI_FOUND)
 465   set(_FOAM_USE_MPI ON)
 466 else()
 467   set(_FOAM_USE_MPI OFF)
 468 endif()
 469 foam_option(FOAM_USE_MPI "Use MPI"
 470   "Build ${CMAKE_PROJECT} against MPI parallel libraries" ${_FOAM_USE_MPI})
 471 mark_as_advanced(FOAM_USE_MPI)
 472 if(FOAM_USE_MPI AND NOT MPI_FOUND)
 473   message(SEND_ERROR
 474     "FOAM_ENABLE_MPI is true, but MPI cannot be found.\n"
 475     "If you have MPI installed on your system, edit the variables\n"
 476     "MPI_INCLUDE_DIR and MPI_LIBRARY in the cache, else disable the\n"
 477     "setting FOAM_USE_MPI."
 478   )
 479 endif()
 480
 481 # find readline
 482 find_package(Readline)
 483
 484 # substitution for build-tree and install-tree as used by
 485 # foam_configure_files.
 486 set(FOAM_CONFIGURE_FILES_VARIABLES
 487   FOAM_DATA_DIR
 488     "${CMAKE_BINARY_DIR}/data"
 489     "${FOAM_INSTALL_DATA_PATH}"
 490   FOAM_LOCAL_DOC_DIR
 491     "${CMAKE_BINARY_DIR}/doc"
 492     "${FOAM_INSTALL_DOC_PATH}"
 493   FOAM_BIN_DIR
 494     "${CMAKE_BINARY_DIR}/bin"
 495     "${FOAM_INSTALL_BIN_PATH}"
 496   FOAM_LIB_DIR
 497     "${CMAKE_BINARY_DIR}/lib/FreeFOAM-${FOAM_VERSION_FULL}"
 498     "${FOAM_INSTALL_LIBRARY_PATH}"
 499   FOAM_LIBEXEC_DIR
 500     "${CMAKE_BINARY_DIR}/libexec/FreeFOAM/${FOAM_VERSION_FULL}"
 501     "${FOAM_INSTALL_LIBEXEC_PATH}"
 502   FOAM_FRAMEWORK_DIR
 503     "${CMAKE_BINARY_DIR}/Library/Frameworks"
 504     "${FOAM_INSTALL_FRAMEWORK_PATH}"
 505   FOAM_INCLUDE_DIR
 506     "${CMAKE_BINARY_DIR}/include"
 507     "${FOAM_INSTALL_HEADER_PATH}"
 508   FOAM_CONFIG_DIR
 509     "${CMAKE_BINARY_DIR}/etc"
 510     "${FOAM_INSTALL_CONFIG_PATH}"
 511   FOAM_CMAKECONFIG_DIR
 512     "${CMAKE_BINARY_DIR}/CMake"
 513     "${FOAM_INSTALL_CMAKE_PATH}"
 514   FOAM_PYTHON_DIR
 515     "${CMAKE_BINARY_DIR}/data/python"
 516     "${FOAM_INSTALL_PYTHON_PATH}"
 517   FOAM_IS_INSTALLED
 518     "FALSE"
 519     "TRUE"
 520   )
 521 if(WIN32)
 522   list(APPEND FOAM_CONFIGURE_FILES_VARIABLES
 523     FOAM_PLUGIN_DIR
 524       "${CMAKE_BINARY_DIR}/lib/FreeFOAM-${FOAM_VERSION_FULL}"
 525       "${FOAM_INSTALL_LIBRARY_PATH}")
 526 else()
 527   list(APPEND FOAM_CONFIGURE_FILES_VARIABLES
 528     FOAM_PLUGIN_DIR
 529       "${CMAKE_BINARY_DIR}/lib/FreeFOAM-${FOAM_VERSION_FULL}/plugins"
 530       "${FOAM_INSTALL_PLUGIN_PATH}")
 531 endif()
 532 if(FOAM_USE_LOCAL_DOXYGEN_DOCS)
 533   list(APPEND FOAM_CONFIGURE_FILES_VARIABLES
 534     FOAM_DOC_DIR "${CMAKE_BINARY_DIR}/doc" "${FOAM_INSTALL_DOC_PATH}")
 535 else()
 536   set(_sf_doc "http://freefoam.sf.net/doc/${FOAM_VERSION_FULL}")
 537   list(APPEND FOAM_CONFIGURE_FILES_VARIABLES
 538     FOAM_DOC_DIR "${_sf_doc}" "${_sf_doc}")
 539 endif()
 540
 541 # thirdparty libraries
 542 foam_thirdparty_option(Metis
 543   "Required by the metis decomposition method"
 544   Metis TRUE ON)
 545 if(FOAM_ENABLE_METIS)
 546   if(FOAM_ENABLE_METIS AND METIS_REQUIRES_MPI AND NOT FOAM_USE_MPI)
 547     message(SEND_ERROR
 548       "Your metis implementation requires FOAM_USE_MPI to be enabled."
 549       "If you don't have/want MPI, enable FOAM_BUILD_PRIVATE_METIS instead.")
 550   endif()
 551 endif()
 552 foam_thirdparty_option(ParMetis
 553   "Required by the parmetis decomposition method"
 554   ParMetis TRUE ${FOAM_USE_MPI}
 555   PARMETIS_metis_LIBRARY PARMETIS_parmetis_LIBRARY)
 556 if(FOAM_ENABLE_PARMETIS AND NOT FOAM_USE_MPI)
 557   message(SEND_ERROR
 558     "ParMetis requires FOAM_USE_MPI to be enabled.")
 559 endif()
 560 if(FOAM_ENABLE_PARMETIS AND NOT FOAM_ENABLE_METIS)
 561   message(SEND_ERROR
 562     "ParMetis requires FOAM_ENABLE_METIS to be enabled.")
 563 endif()
 564 set(SCOTCH_USE_ERREXIT TRUE)
 565 foam_thirdparty_option(SCOTCH "" SCOTCH FALSE ON SCOTCH_scotch_LIBRARY
 566   SCOTCH_scotcherr_LIBRARY SCOTCH_scotcherrexit_LIBRARY)
 567 # do not enable mgridgen by default (licensing issues)
 568 if(NOT FOAM_DOUBLE_PRECISION)
 569   set(MGRIDGEN_USE_REAL ON)
 570 endif()
 571 foam_thirdparty_option(MGRIDGEN
 572   "Required by the MGridGen GAMG agglomerator. LICENSE UNCLEAR"
 573   MGRIDGEN TRUE OFF)
 574 # do not enable libccmio by default (licensing issues)
 575 foam_thirdparty_option(ccmio
 576   "Required by ccm26ToFoam. REQUIRES PERMISSION BY CDADAPCO!"
 577   Ccmio TRUE OFF)
 578 foam_thirdparty_option(zlib "" ZLIB FALSE ON)
 579
 580 # figure out default Pstream library
 581 if(FOAM_USE_MPI)
 582   set(_FOAM_DEFAULT_PSTREAM mpi)
 583 else()
 584   set(_FOAM_DEFAULT_PSTREAM dummy)
 585 endif()
 586 set(FOAM_DEFAULT_PSTREAM ${_FOAM_DEFAULT_PSTREAM} CACHE STRING
 587   "Default Pstream library implementation [dummy|mpi]")
 588 mark_as_advanced(FOAM_DEFAULT_PSTREAM)
 589
 590 # find m4 macro processor
 591 find_program(M4_EXECUTABLE m4 DOC "Path to the m4 macro processor")
 592 mark_as_advanced(M4_EXECUTABLE)
 593 if(NOT M4_EXECUTABLE)
 594   message("WARNING: Failed to find M4 macro processor.\n"
 595     "Some of the tutorials will fail if it can't be found.")
 596   set(M4_EXECUTABLE m4)
 597 endif()
 598
 599 # on APPLE use cp -R -P -p, otherwise use cp -a
 600 if(APPLE)
 601   set(FOAM_CP_A_FLAGS "-R -P -p")
 602 else()
 603   set(FOAM_CP_A_FLAGS "-a")
 604 endif()
 605
 606 # execinfo.h and cxxabi.h only work using GNU gcc and Debug config
 607 # assume that if we have execinfo.h, cxxabi.h is also present.
 608 if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_BUILD_TYPE STREQUAL Debug)
 609   find_package(Execinfo)
 610 endif()
 611
 612 # create the FOAMConfig.h file
 613 configure_file(${CMAKE_SOURCE_DIR}/FOAMConfig.h.in
 614   ${CMAKE_BINARY_DIR}/include/FOAMConfig.h @ONLY)
 615
 616 # on Solaris/SunOS fix up the shebangs
 617 if(CMAKE_SYSTEM_NAME STREQUAL SunOS AND
 618     NOT EXISTS ${CMAKE_BINARY_DIR}/replaceAllShellSun.run)
 619   message(STATUS "Fixing shell-interpreter for SunOS and Solaris")
 620   execute_process(
 621     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun bin
 622     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun data
 623     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun tutorials
 624     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun doc
 625     COMMAND ${CMAKE_COMMAND} -E touch${CMAKE_BINARY_DIR}/replaceAllShellSun.run
 626     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
 627     )
 628 endif()
 629
 630 # set up defines
 631 set(FOAM_COMPILE_DEFINITIONS
 632   -D${FOAM_PRECISION}
 633   -DNoRepository
 634   -D${FOAM_OS}
 635   )
 636 if(APPLE)
 637   list(APPEND FOAM_COMPILE_DEFINITIONS -Ddarwin)
 638 endif()
 639 add_definitions(${FOAM_COMPILE_DEFINITIONS})
 640
 641 # set up include-directories for own headers
 642 include_directories(${CMAKE_BINARY_DIR}/include)
 643
 644 # set up version info checks and updating of global.C
 645 set(FOAM_HAVE_GIT FALSE)
 646 if(EXISTS "${CMAKE_SOURCE_DIR}/.git/config")
 647   find_package(Git)
 648   if(GIT_FOUND)
 649     set(FOAM_HAVE_GIT TRUE)
 650     option(FOAM_VERSION_CHECK_WARN_ONLY
 651       "Only warn if the version numbers are wrong" FALSE)
 652     mark_as_advanced(FOAM_VERSION_CHECK_WARN_ONLY)
 653     configure_file(CMake/ConfigureGlobalC.cmake.in
 654       "${CMAKE_BINARY_DIR}/CMake/ConfigureGlobalC.cmake" @ONLY)
 655     add_custom_target(version_check ALL
 656       COMMAND "${PYTHON_EXECUTABLE}"
 657         "${CMAKE_BINARY_DIR}/data/utilities/checkVersionInfo.py"
 658         ${_CHECK_VERSION_INFO_ARGS}
 659       DEPENDS "${CMAKE_BINARY_DIR}/data/utilities/checkVersionInfo.py"
 660       COMMENT "Checking version information"
 661       VERBATIM)
 662   else()
 663     message(WARNING
 664       "Not performing version checks because GIT_EXECUTABLE is missing")
 665   endif()
 666 else()
 667   message(STATUS
 668     "Not performing version checks because not in a Git checkout")
 669 endif()
 670
 671 if(NOT FOAM_HAVE_GIT)
 672   if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.build.cmake)
 673     message(SEND_ERROR "If not in a Git checkout, .build.cmake is required")
 674   endif()
 675   include(${CMAKE_SOURCE_DIR}/.build.cmake)
 676 endif()
 677
 678 # helper variables to force linking on some systems
 679 set(_TURBULENCE_MODELS ${PROJECT_SOURCE_DIR}/src/turbulenceModels)
 680 set(FORCE_LINK_COMPRESSIBLE_RAS_MODELS
 681   ${_TURBULENCE_MODELS}/compressible/RAS/RASModel/forceLink.C)
 682 set(FORCE_LINK_COMPRESSIBLE_LES_MODELS
 683   ${_TURBULENCE_MODELS}/compressible/LES/LESModel/forceLink.C)
 684 set(FORCE_LINK_INCOMPRESSIBLE_RAS_MODELS
 685   ${_TURBULENCE_MODELS}/incompressible/RAS/RASModel/forceLink.C)
 686 set(FORCE_LINK_INCOMPRESSIBLE_LES_MODELS
 687   ${_TURBULENCE_MODELS}/incompressible/LES/LESModel/forceLink.C)
 688 set(FORCE_LINK_GENERIC_PATCH_FIELDS
 689   ${PROJECT_SOURCE_DIR}/src/genericPatchFields/include/forceLink.C)
 690 set(FORCE_LINK_RADIATION
 691   ${PROJECT_SOURCE_DIR}/src/thermophysicalModels/radiation/radiationModel/radiationModel/forceLink.C)
 692 set(FORCE_LINK_COAL_COMBUSTION
 693   ${PROJECT_SOURCE_DIR}/src/lagrangian/coalCombustion/include/forceLink.C)
 694 set(FORCE_LINK_INTERFACE_PROPERTIES
 695   ${PROJECT_SOURCE_DIR}/src/transportModels/interfaceProperties/forceLink.C)
 696
 697 # descend into the sources...
 698 add_subdirectory(bin)
 699 add_subdirectory(etc)
 700 add_subdirectory(data)
 701 add_subdirectory(src)
 702 add_subdirectory(applications)
 703 add_subdirectory(tutorials)
 704 # doc *must* be last, else manpage and Doxygen generation fails
 705 add_subdirectory(doc)
 706
 707 # export the library dependencies to the build tree
 708 foam_export_targets_to_build_tree(${PROJECT_NAME}LibraryDepends)
 709 export(PACKAGE ${PROJECT_NAME})
 710
 711 # write the doc index file and install it
 712 foam_write_doc_index()
 713 install(FILES
 714   ${CMAKE_BINARY_DIR}/InstallFiles/data/DoxyDocIndex
 715   DESTINATION ${FOAM_INSTALL_DATA_PATH}
 716   COMPONENT data
 717   )
 718
 719 # create ${PROJECT_NAME}Config.cmake ${PROJECT_NAME}Use.cmake,
 720 # ${PROJECT_NAME}Utilities.cmake and ${PROJECT_NAME}WmakeCompatibility.cmake
 721 # for the build and install tree
 722 foam_configure_files(ConfigInstallFiles
 723   "CMake/FOAMConfig.cmake.in==CMake/${PROJECT_NAME}Config.cmake"
 724   "CMake/FOAMUse.cmake.in==CMake/${PROJECT_NAME}Use.cmake"
 725   "CMake/FOAMWmakeCompatibility.cmake.in==CMake/${PROJECT_NAME}WmakeCompatibility.cmake"
 726   COPYONLY
 727   "CMake/FOAMUtilities.cmake==CMake/${PROJECT_NAME}Utilities.cmake"
 728   )
 729
 730 # install the CMake config files
 731 install(FILES
 732   ${ConfigInstallFiles}
 733   DESTINATION ${FOAM_INSTALL_CMAKE_PATH}
 734   COMPONENT dev
 735   )
 736
 737 # install the ${PROJECT_NAME}LibraryDepends.cmake file
 738 install(EXPORT ${PROJECT_NAME}LibraryDepends
 739   DESTINATION ${FOAM_INSTALL_CMAKE_PATH}
 740   NAMESPACE FOAM_
 741   COMPONENT dev
 742   )
 743
 744 # uninstall target
 745 configure_file(
 746   "${CMAKE_SOURCE_DIR}/CMake/Modules/cmake_uninstall.cmake.in"
 747   "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
 748   @ONLY
 749   )
 750
 751 add_custom_target(uninstall
 752   "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
 753   )
 754
 755 # print cool feature summary
 756 foam_print_feature_summary()
 757
 758 # ------------------------- vim: set sw=2 sts=2 et: --------------- end-of-file