Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in / Register
Toggle navigation
Menu
Open sidebar
Nektar
Nektar
Commits
f9450fcb
Commit
f9450fcb
authored
Aug 18, 2016
by
Kilian Lackhove
Browse files
Merge branch 'master' into feature/APE-forcing
# Conflicts: # CHANGELOG.md
parents
4a01ed1a
d199ea62
Changes
182
Hide whitespace changes
Inline
Side-by-side
.clang-format
View file @
f9450fcb
...
...
@@ -13,4 +13,4 @@ AllowShortLoopsOnASingleLine: false
IndentCaseLabels: true
Standard: Cpp03
AccessModifierOffset: -4
BinPackParameters:
fals
e
BinPackParameters:
tru
e
CHANGELOG.md
View file @
f9450fcb
...
...
@@ -3,9 +3,11 @@ Changelog
v4.4.0
------
**Library
:
**
**Library**
:
-
Add support for variable polynomial order for 3D simulations with continuous
Galerkin discretisation (!604)
-
Bump version of gsmpi to suppress autotuning output unless
`--verbose`
is
specified (!652)
-
Add support for variable polynomial order with periodic boundary conditions
(!658)
-
Statistics are now printed for lowest level of multi-level static condensation
...
...
@@ -15,8 +17,15 @@ v4.4.0
-
New FieldUtils library allows support for most
`FieldConvert`
post-processing
operations during simulation using a new filter (!589)
-
Adjust CMake dependencies to reduce compile time (!671)
-
Homogeneous1D dealiasing improvements (!622)
-
Add support for HDF5 as an alternative output to XML-based output, including
refactoring of FieldIO, improvements to MPI interface and added communicators
to boundary conditions (!615)
-
Update Body/Field forces at each timestep (!665)
**ADRSolver:**
-
Add a projection equation system for C^0 projections (!675)
**APESolver:**
-
Use a continuous basefield projection and revert to constant c formulation (!664)
-
Added ability to compute CFL number (!664)
...
...
@@ -25,14 +34,30 @@ v4.4.0
**IncNavierStokesSolver:**
-
Add ability to simulate additional scalar fields (!624)
-
Improve performance when using homogeneous dealiasing (!622)
**FieldConvert:**
-
Allow equi-spaced output for 1D and 2DH1D fields (!613)
**NekMesh:**
-
Modify curve module to allow for spline input (!628)
-
Add STL surface writer module (!668)
-
New module for inserting an alternate high-order surface into the working
mesh (!669)
-
Improvements to mesh linearisation module (!659)
-
Add support for Gmsh high-order output (!679)
**FieldConvert:**
-
Move all modules to a new library, FieldUtils, to support post-processing
during simulations (!589)
-
Add module to stretch homogeneous direction (!609)
-
Add module to add composite ID of elements as a field (!674)
v4.3.4
------
**Library:**
-
Fix performance issue with
`v_ExtractDataToCoeffs`
for post-processing of large
simulations (!672)
v4.3.3
------
...
...
CMakeLists.txt
View file @
f9450fcb
...
...
@@ -178,6 +178,7 @@ ENDIF ()
INCLUDE
(
ThirdPartyTinyxml
)
INCLUDE
(
ThirdPartyLoki
)
INCLUDE
(
ThirdPartyMetis
)
INCLUDE
(
ThirdPartyHDF5
)
INCLUDE
(
ThirdPartyScotch
)
INCLUDE
(
ThirdPartyZlib
)
INCLUDE
(
ThirdPartyBoost
)
...
...
cmake/FindHDF5.cmake
0 → 100644
View file @
f9450fcb
#.rst:
# FindHDF5
# --------
#
# Find HDF5, a library for reading and writing self describing array data.
#
#
#
# This module invokes the HDF5 wrapper compiler that should be installed
# alongside HDF5. Depending upon the HDF5 Configuration, the wrapper
# compiler is called either h5cc or h5pcc. If this succeeds, the module
# will then call the compiler with the -show argument to see what flags
# are used when compiling an HDF5 client application.
#
# The module will optionally accept the COMPONENTS argument. If no
# COMPONENTS are specified, then the find module will default to finding
# only the HDF5 C library. If one or more COMPONENTS are specified, the
# module will attempt to find the language bindings for the specified
# components. The only valid components are C, CXX, Fortran, HL, and
# Fortran_HL. If the COMPONENTS argument is not given, the module will
# attempt to find only the C bindings.
#
# On UNIX systems, this module will read the variable
# HDF5_USE_STATIC_LIBRARIES to determine whether or not to prefer a
# static link to a dynamic link for HDF5 and all of it's dependencies.
# To use this feature, make sure that the HDF5_USE_STATIC_LIBRARIES
# variable is set before the call to find_package.
#
# To provide the module with a hint about where to find your HDF5
# installation, you can set the environment variable HDF5_ROOT. The
# Find module will then look in this path when searching for HDF5
# executables, paths, and libraries.
#
# Both the serial and parallel HDF5 wrappers are considered and the first
# directory to contain either one will be used. In the event that both appear
# in the same directory the serial version is preferentially selected. This
# behavior can be reversed by setting the variable HDF5_PREFER_PARALLEL to
# true.
#
# In addition to finding the includes and libraries required to compile
# an HDF5 client application, this module also makes an effort to find
# tools that come with the HDF5 distribution that may be useful for
# regression testing.
#
# This module will define the following variables:
#
# ::
#
# HDF5_INCLUDE_DIRS - Location of the hdf5 includes
# HDF5_INCLUDE_DIR - Location of the hdf5 includes (deprecated)
# HDF5_DEFINITIONS - Required compiler definitions for HDF5
# HDF5_C_LIBRARIES - Required libraries for the HDF5 C bindings.
# HDF5_CXX_LIBRARIES - Required libraries for the HDF5 C++ bindings
# HDF5_Fortran_LIBRARIES - Required libraries for the HDF5 Fortran bindings
# HDF5_HL_LIBRARIES - Required libraries for the HDF5 high level API
# HDF5_Fortran_HL_LIBRARIES - Required libraries for the high level Fortran
# bindings.
# HDF5_LIBRARIES - Required libraries for all requested bindings
# HDF5_FOUND - true if HDF5 was found on the system
# HDF5_VERSION - HDF5 version in format Major.Minor.Release
# HDF5_LIBRARY_DIRS - the full set of library directories
# HDF5_IS_PARALLEL - Whether or not HDF5 was found with parallel IO support
# HDF5_C_COMPILER_EXECUTABLE - the path to the HDF5 C wrapper compiler
# HDF5_CXX_COMPILER_EXECUTABLE - the path to the HDF5 C++ wrapper compiler
# HDF5_Fortran_COMPILER_EXECUTABLE - the path to the HDF5 Fortran wrapper compiler
# HDF5_DIFF_EXECUTABLE - the path to the HDF5 dataset comparison tool
#=============================================================================
# Copyright 2015 Axel Huebl, Helmholtz-Zentrum Dresden - Rossendorf
# Copyright 2009 Kitware, Inc.
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# This module is maintained by Will Dicharry <wdicharry@stellarscience.com>.
include
(
SelectLibraryConfigurations
)
include
(
FindPackageHandleStandardArgs
)
# List of the valid HDF5 components
set
(
HDF5_VALID_COMPONENTS
C
CXX
Fortran
HL
Fortran_HL
)
# Validate the list of find components.
if
(
NOT HDF5_FIND_COMPONENTS
)
set
(
HDF5_LANGUAGE_BINDINGS
"C"
)
else
()
# add the extra specified components, ensuring that they are valid.
foreach
(
component
${
HDF5_FIND_COMPONENTS
}
)
list
(
FIND HDF5_VALID_COMPONENTS
${
component
}
component_location
)
if
(
${
component_location
}
EQUAL -1
)
message
(
FATAL_ERROR
"
\"
${
component
}
\"
is not a valid HDF5 component."
)
else
()
list
(
APPEND HDF5_LANGUAGE_BINDINGS
${
component
}
)
endif
()
endforeach
()
endif
()
# Determine whether to search for serial or parallel executable first
if
(
HDF5_PREFER_PARALLEL
)
set
(
HDF5_C_COMPILER_NAMES h5pcc h5cc
)
set
(
HDF5_CXX_COMPILER_NAMES h5pc++ h5c++
)
set
(
HDF5_Fortran_COMPILER_NAMES h5pfc h5fc
)
else
()
set
(
HDF5_C_COMPILER_NAMES h5cc h5pcc
)
set
(
HDF5_CXX_COMPILER_NAMES h5c++ h5pc++
)
set
(
HDF5_Fortran_COMPILER_NAMES h5fc h5pfc
)
endif
()
# try to find the HDF5 wrapper compilers
find_program
(
HDF5_C_COMPILER_EXECUTABLE
NAMES
${
HDF5_C_COMPILER_NAMES
}
HINTS ENV HDF5_ROOT
PATH_SUFFIXES bin Bin
DOC
"HDF5 Wrapper compiler. Used only to detect HDF5 compile flags."
)
mark_as_advanced
(
HDF5_C_COMPILER_EXECUTABLE
)
find_program
(
HDF5_CXX_COMPILER_EXECUTABLE
NAMES
${
HDF5_CXX_COMPILER_NAMES
}
HINTS ENV HDF5_ROOT
PATH_SUFFIXES bin Bin
DOC
"HDF5 C++ Wrapper compiler. Used only to detect HDF5 compile flags."
)
mark_as_advanced
(
HDF5_CXX_COMPILER_EXECUTABLE
)
find_program
(
HDF5_Fortran_COMPILER_EXECUTABLE
NAMES
${
HDF5_Fortran_COMPILER_NAMES
}
HINTS ENV HDF5_ROOT
PATH_SUFFIXES bin Bin
DOC
"HDF5 Fortran Wrapper compiler. Used only to detect HDF5 compile flags."
)
mark_as_advanced
(
HDF5_Fortran_COMPILER_EXECUTABLE
)
unset
(
HDF5_C_COMPILER_NAMES
)
unset
(
HDF5_CXX_COMPILER_NAMES
)
unset
(
HDF5_Fortran_COMPILER_NAMES
)
find_program
(
HDF5_DIFF_EXECUTABLE
NAMES h5diff
HINTS ENV HDF5_ROOT
PATH_SUFFIXES bin Bin
DOC
"HDF5 file differencing tool."
)
mark_as_advanced
(
HDF5_DIFF_EXECUTABLE
)
# Invoke the HDF5 wrapper compiler. The compiler return value is stored to the
# return_value argument, the text output is stored to the output variable.
macro
(
_HDF5_invoke_compiler language output return_value
)
if
(
HDF5_
${
language
}
_COMPILER_EXECUTABLE
)
exec_program
(
${
HDF5_
${
language
}
_COMPILER_EXECUTABLE
}
ARGS -show
OUTPUT_VARIABLE
${
output
}
RETURN_VALUE
${
return_value
}
)
if
(
${${
return_value
}}
EQUAL 0
)
# do nothing
else
()
message
(
STATUS
"Unable to determine HDF5
${
language
}
flags from HDF5 wrapper."
)
endif
()
endif
()
endmacro
()
# Parse a compile line for definitions, includes, library paths, and libraries.
macro
(
_HDF5_parse_compile_line
compile_line_var
include_paths
definitions
library_paths
libraries
)
# See if we are running using an MPI wrapper. If we are, then try to also
# add include directories from here as well.
string
(
REGEX MATCH
"^mpi[^ ]+"
mpi_wrapper
"
${${
compile_line_var
}}
"
)
if
(
mpi_wrapper
)
# Invoke MPI wrapper to search for additional include directories
exec_program
(
${
mpi_wrapper
}
ARGS -show
OUTPUT_VARIABLE mpi_wrapper_output
RETURN_VALUE mpi_wrapper_return
)
if
(
${
mpi_wrapper_return
}
EQUAL 0
)
string
(
REGEX MATCHALL
"-I([^
\"
]+)"
include_path_flags
"
${
mpi_wrapper_output
}
"
)
foreach
(
IPATH
${
include_path_flags
}
)
string
(
REGEX REPLACE
"^-I"
""
IPATH
${
IPATH
}
)
string
(
REPLACE
"//"
"/"
IPATH
${
IPATH
}
)
list
(
APPEND
${
include_paths
}
${
IPATH
}
)
endforeach
()
endif
()
endif
()
# Match the include paths
string
(
REGEX MATCHALL
"-I([^
\"
]+)"
include_path_flags
"
${${
compile_line_var
}}
"
)
foreach
(
IPATH
${
include_path_flags
}
)
string
(
REGEX REPLACE
"^-I"
""
IPATH
${
IPATH
}
)
string
(
REPLACE
"//"
"/"
IPATH
${
IPATH
}
)
list
(
APPEND
${
include_paths
}
${
IPATH
}
)
endforeach
()
# Match the definitions
string
(
REGEX MATCHALL
"-D[^ ]*"
definition_flags
"
${${
compile_line_var
}}
"
)
foreach
(
DEF
${
definition_flags
}
)
list
(
APPEND
${
definitions
}
${
DEF
}
)
endforeach
()
# Match the library paths
string
(
REGEX MATCHALL
"-L([^
\"
]+|
\"
[^
\"
]+
\"
)"
library_path_flags
"
${${
compile_line_var
}}
"
)
foreach
(
LPATH
${
library_path_flags
}
)
string
(
REGEX REPLACE
"^-L"
""
LPATH
${
LPATH
}
)
string
(
REPLACE
"//"
"/"
LPATH
${
LPATH
}
)
list
(
APPEND
${
library_paths
}
${
LPATH
}
)
endforeach
()
# now search for the library names specified in the compile line (match -l...)
# match only -l's preceded by a space or comma
# this is to exclude directory names like xxx-linux/
string
(
REGEX MATCHALL
"[, ]-l([^
\"
, ]+)"
library_name_flags
"
${${
compile_line_var
}}
"
)
# strip the -l from all of the library flags and add to the search list
foreach
(
LIB
${
library_name_flags
}
)
string
(
REGEX REPLACE
"^[, ]-l"
""
LIB
${
LIB
}
)
list
(
APPEND
${
libraries
}
${
LIB
}
)
endforeach
()
endmacro
()
# Try to find HDF5 using an installed hdf5-config.cmake
if
(
NOT HDF5_FOUND
)
find_package
(
HDF5 QUIET NO_MODULE
)
if
(
HDF5_FOUND
)
set
(
HDF5_INCLUDE_DIRS
${
HDF5_INCLUDE_DIR
}
)
set
(
HDF5_LIBRARIES
)
set
(
HDF5_C_TARGET hdf5
)
set
(
HDF5_CXX_TARGET hdf5_cpp
)
set
(
HDF5_HL_TARGET hdf5_hl
)
set
(
HDF5_Fortran_TARGET hdf5_fortran
)
set
(
HDF5_Fortran_HL_TARGET hdf5_hl_fortran
)
foreach
(
_component
${
HDF5_LANGUAGE_BINDINGS
}
)
list
(
FIND HDF5_VALID_COMPONENTS
${
_component
}
_component_location
)
get_target_property
(
_comp_location
${
HDF5_
${
_component
}
_TARGET
}
LOCATION
)
if
(
_comp_location
)
set
(
HDF5_
${
_component
}
_LIBRARY
${
_comp_location
}
CACHE PATH
"HDF5
${
_component
}
library"
)
mark_as_advanced
(
HDF5_
${
_component
}
_LIBRARY
)
list
(
APPEND HDF5_LIBRARIES
${
HDF5_
${
_component
}
_LIBRARY
}
)
endif
()
endforeach
()
endif
()
endif
()
if
(
NOT HDF5_FOUND
)
_HDF5_invoke_compiler
(
C HDF5_C_COMPILE_LINE HDF5_C_RETURN_VALUE
)
_HDF5_invoke_compiler
(
CXX HDF5_CXX_COMPILE_LINE HDF5_CXX_RETURN_VALUE
)
_HDF5_invoke_compiler
(
Fortran HDF5_Fortran_COMPILE_LINE HDF5_Fortran_RETURN_VALUE
)
set
(
HDF5_HL_COMPILE_LINE
${
HDF5_C_COMPILE_LINE
}
)
set
(
HDF5_Fortran_HL_COMPILE_LINE
${
HDF5_Fortran_COMPILE_LINE
}
)
# seed the initial lists of libraries to find with items we know we need
set
(
HDF5_C_LIBRARY_NAMES_INIT hdf5
)
set
(
HDF5_HL_LIBRARY_NAMES_INIT hdf5_hl
${
HDF5_C_LIBRARY_NAMES_INIT
}
)
set
(
HDF5_CXX_LIBRARY_NAMES_INIT hdf5_cpp
${
HDF5_C_LIBRARY_NAMES_INIT
}
)
set
(
HDF5_Fortran_LIBRARY_NAMES_INIT hdf5_fortran
${
HDF5_C_LIBRARY_NAMES_INIT
}
)
set
(
HDF5_Fortran_HL_LIBRARY_NAMES_INIT hdf5hl_fortran hdf5_hl
${
HDF5_Fortran_LIBRARY_NAMES_INIT
}
)
foreach
(
LANGUAGE
${
HDF5_LANGUAGE_BINDINGS
}
)
if
(
HDF5_
${
LANGUAGE
}
_COMPILE_LINE
)
_HDF5_parse_compile_line
(
HDF5_
${
LANGUAGE
}
_COMPILE_LINE
HDF5_
${
LANGUAGE
}
_INCLUDE_FLAGS
HDF5_
${
LANGUAGE
}
_DEFINITIONS
HDF5_
${
LANGUAGE
}
_LIBRARY_DIRS
HDF5_
${
LANGUAGE
}
_LIBRARY_NAMES
)
# take a guess that the includes may be in the 'include' sibling
# directory of a library directory.
foreach
(
dir
${
HDF5_
${
LANGUAGE
}
_LIBRARY_DIRS
}
)
list
(
APPEND HDF5_
${
LANGUAGE
}
_INCLUDE_FLAGS
${
dir
}
/../include
)
endforeach
()
endif
()
# set the definitions for the language bindings.
list
(
APPEND HDF5_DEFINITIONS
${
HDF5_
${
LANGUAGE
}
_DEFINITIONS
}
)
# find the HDF5 include directories
if
(
${
LANGUAGE
}
MATCHES
"Fortran"
)
set
(
HDF5_INCLUDE_FILENAME hdf5.mod
)
else
()
set
(
HDF5_INCLUDE_FILENAME hdf5.h
)
endif
()
find_path
(
HDF5_
${
LANGUAGE
}
_INCLUDE_DIR
${
HDF5_INCLUDE_FILENAME
}
HINTS
${
HDF5_
${
LANGUAGE
}
_INCLUDE_FLAGS
}
ENV
HDF5_ROOT
PATHS
$ENV{HOME}/.local/include
PATH_SUFFIXES
include
Include
)
mark_as_advanced
(
HDF5_
${
LANGUAGE
}
_INCLUDE_DIR
)
list
(
APPEND HDF5_INCLUDE_DIRS
${
HDF5_
${
LANGUAGE
}
_INCLUDE_DIR
}
)
set
(
HDF5_
${
LANGUAGE
}
_LIBRARY_NAMES
${
HDF5_
${
LANGUAGE
}
_LIBRARY_NAMES_INIT
}
${
HDF5_
${
LANGUAGE
}
_LIBRARY_NAMES
}
)
# find the HDF5 libraries
foreach
(
LIB
${
HDF5_
${
LANGUAGE
}
_LIBRARY_NAMES
}
)
if
(
UNIX AND HDF5_USE_STATIC_LIBRARIES
)
# According to bug 1643 on the CMake bug tracker, this is the
# preferred method for searching for a static library.
# See https://cmake.org/Bug/view.php?id=1643. We search
# first for the full static library name, but fall back to a
# generic search on the name if the static search fails.
set
(
THIS_LIBRARY_SEARCH_DEBUG lib
${
LIB
}
d.a
${
LIB
}
d
)
set
(
THIS_LIBRARY_SEARCH_RELEASE lib
${
LIB
}
.a
${
LIB
}
)
else
()
set
(
THIS_LIBRARY_SEARCH_DEBUG
${
LIB
}
d
)
set
(
THIS_LIBRARY_SEARCH_RELEASE
${
LIB
}
)
endif
()
find_library
(
HDF5_
${
LIB
}
_LIBRARY_DEBUG
NAMES
${
THIS_LIBRARY_SEARCH_DEBUG
}
HINTS
${
HDF5_
${
LANGUAGE
}
_LIBRARY_DIRS
}
ENV HDF5_ROOT
PATH_SUFFIXES lib Lib
)
find_library
(
HDF5_
${
LIB
}
_LIBRARY_RELEASE
NAMES
${
THIS_LIBRARY_SEARCH_RELEASE
}
HINTS
${
HDF5_
${
LANGUAGE
}
_LIBRARY_DIRS
}
ENV HDF5_ROOT
PATH_SUFFIXES lib Lib
)
select_library_configurations
(
HDF5_
${
LIB
}
)
list
(
APPEND HDF5_
${
LANGUAGE
}
_LIBRARIES
${
HDF5_
${
LIB
}
_LIBRARY
}
)
endforeach
()
list
(
APPEND HDF5_LIBRARY_DIRS
${
HDF5_
${
LANGUAGE
}
_LIBRARY_DIRS
}
)
# Append the libraries for this language binding to the list of all
# required libraries.
list
(
APPEND HDF5_LIBRARIES
${
HDF5_
${
LANGUAGE
}
_LIBRARIES
}
)
endforeach
()
# We may have picked up some duplicates in various lists during the above
# process for the language bindings (both the C and C++ bindings depend on
# libz for example). Remove the duplicates. It appears that the default
# CMake behavior is to remove duplicates from the end of a list. However,
# for link lines, this is incorrect since unresolved symbols are searched
# for down the link line. Therefore, we reverse the list, remove the
# duplicates, and then reverse it again to get the duplicates removed from
# the beginning.
macro
(
_remove_duplicates_from_beginning _list_name
)
list
(
REVERSE
${
_list_name
}
)
list
(
REMOVE_DUPLICATES
${
_list_name
}
)
list
(
REVERSE
${
_list_name
}
)
endmacro
()
if
(
HDF5_INCLUDE_DIRS
)
_remove_duplicates_from_beginning
(
HDF5_INCLUDE_DIRS
)
endif
()
if
(
HDF5_LIBRARY_DIRS
)
_remove_duplicates_from_beginning
(
HDF5_LIBRARY_DIRS
)
endif
()
# If the HDF5 include directory was found, open H5pubconf.h to determine if
# HDF5 was compiled with parallel IO support
set
(
HDF5_IS_PARALLEL FALSE
)
set
(
HDF5_VERSION
""
)
foreach
(
_dir IN LISTS HDF5_INCLUDE_DIRS
)
foreach
(
_hdr
"
${
_dir
}
/H5pubconf.h"
"
${
_dir
}
/H5pubconf-64.h"
"
${
_dir
}
/H5pubconf-32.h"
)
if
(
EXISTS
"
${
_hdr
}
"
)
file
(
STRINGS
"
${
_hdr
}
"
HDF5_HAVE_PARALLEL_DEFINE
REGEX
"HAVE_PARALLEL 1"
)
if
(
HDF5_HAVE_PARALLEL_DEFINE
)
set
(
HDF5_IS_PARALLEL TRUE
)
endif
()
unset
(
HDF5_HAVE_PARALLEL_DEFINE
)
file
(
STRINGS
"
${
_hdr
}
"
HDF5_VERSION_DEFINE
REGEX
"^[
\t
]*#[
\t
]*define[
\t
]+H5_VERSION[
\t
]+"
)
if
(
"
${
HDF5_VERSION_DEFINE
}
"
MATCHES
"H5_VERSION[
\t
]+
\"
([0-9]+
\\
.[0-9]+
\\
.[0-9]+).*
\"
"
)
set
(
HDF5_VERSION
"
${
CMAKE_MATCH_1
}
"
)
endif
()
unset
(
HDF5_VERSION_DEFINE
)
endif
()
endforeach
()
endforeach
()
set
(
HDF5_IS_PARALLEL
${
HDF5_IS_PARALLEL
}
CACHE BOOL
"HDF5 library compiled with parallel IO support"
)
mark_as_advanced
(
HDF5_IS_PARALLEL
)
# For backwards compatibility we set HDF5_INCLUDE_DIR to the value of
# HDF5_INCLUDE_DIRS
if
(
HDF5_INCLUDE_DIRS
)
set
(
HDF5_INCLUDE_DIR
"
${
HDF5_INCLUDE_DIRS
}
"
)
endif
()
endif
()
find_package_handle_standard_args
(
HDF5
REQUIRED_VARS HDF5_LIBRARIES HDF5_INCLUDE_DIRS
VERSION_VAR HDF5_VERSION
)
cmake/Nektar++Config.cmake.in
View file @
f9450fcb
...
...
@@ -103,6 +103,13 @@ IF( NEKTAR_USE_VTK )
${NEKTAR++_TP_INCLUDE_DIRS} ${VTK_INCLUDE_DIRS})
ENDIF( NEKTAR_USE_VTK )
SET(NEKTAR_USE_HDF5 "@NEKTAR_USE_HDF5@")
IF( NEKTAR_USE_HDF5 )
SET(HDF5_INCLUDE_DIRS "@HDF5_INCLUDE_DIRS@")
SET(NEKTAR++_TP_INCLUDE_DIRS
${NEKTAR++_TP_INCLUDE_DIRS} ${HDF5_INCLUDE_DIRS})
ENDIF( NEKTAR_USE_HDF5 )
# find and add Nektar++ libraries
INCLUDE(${NEKTAR++_LIBRARY_DIRS}/cmake/Nektar++Libraries.cmake)
...
...
cmake/ThirdPartyANN.cmake
View file @
f9450fcb
...
...
@@ -7,11 +7,14 @@
########################################################################
IF
(
NOT WIN32
)
CMAKE_DEPENDENT_OPTION
(
NEKTAR_USE_ANN
"Use ANN routines for performing Approximate Nearest Neighbour searches."
ON
"NEKTAR_USE_MESHGEN"
OFF
)
OPTION
(
NEKTAR_USE_ANN
"Use ANN routines for performing Approximate Nearest Neighbour searches."
OFF
)
ENDIF
(
NOT WIN32
)
IF
(
NEKTAR_USE_MESHGEN
)
SET
(
NEKTAR_USE_ANN ON CACHE BOOL
""
FORCE
)
ENDIF
()
IF
(
NEKTAR_USE_ANN
)
# First search for system ANN installs. Hint /opt/local for MacPorts and
# /usr/local/opt/ann for Homebrew.
...
...
cmake/ThirdPartyCCM.cmake
View file @
f9450fcb
...
...
@@ -2,22 +2,30 @@
#
# ThirdParty configuration for Nektar++
#
# Star CCM i/o
# Star CCM i/o
#
########################################################################
OPTION
(
NEKTAR_USE_CCM
OPTION
(
NEKTAR_USE_CCM
"CCM star i/o library is available."
OFF
)
IF
(
NEKTAR_USE_CCM
)
FIND_LIBRARY
(
CCMIO_LIBRARY NAMES
"ccmio"
"adf"
PATHS /usr/local/lib
${
Nektar++_TP_LIBRARY_DIRS
}
)
set
(
CCMIO_LIBRARIES
ccmio
adf
)
FIND_LIBRARY
(
CCMIO_LIBRARY NAMES
"ccmio"
PATHS /usr/local/lib
${
Nektar++_TP_LIBRARY_DIRS
}
)
IF
(
CCMIO_LIBRARY
)
MESSAGE
(
STATUS
"Found Ccmio:
${
CCMIO_LIBRARY
}
"
)
MESSAGE
(
STATUS
"Found Ccmio:
${
CCMIO_LIBRARY
}
"
)
MARK_AS_ADVANCED
(
CCMIO_LIBRARY
)
ADD_DEFINITIONS
(
-DNEKTAR_USE_CCM
)
FIND_PATH
(
CCMIO_INCLUDE_DIR ccmio.h
)
GET_FILENAME_COMPONENT
(
CCMIO_LIBRARY_PATH
${
CCMIO_LIBRARY
}
PATH
)
LINK_DIRECTORIES
(
${
CCMIO_LIBRARY_PATH
}
)
GET_FILENAME_COMPONENT
(
CCMIO_LIBRARY_DIR
${
CCMIO_LIBRARY
}
PATH
)
INCLUDE_DIRECTORIES
(
NekMesh
${
CCMIO_INCLUDE_DIR
}
)
LINK_DIRECTORIES
(
${
CCMIO_LIBRARY_DIR
}
)
MESSAGE
(
STATUS
${
CCMIO_LIBRARY_DIR
}
)
ELSE
()
MESSAGE
(
FATAL_ERROR
"Cound not find ccmio library"
)
ENDIF
()
...
...
cmake/ThirdPartyHDF5.cmake
0 → 100644
View file @
f9450fcb
########################################################################
#
# ThirdParty configuration for Nektar++
#
# HDF5
#
########################################################################
OPTION
(
NEKTAR_USE_HDF5
"Enable HDF5 I/O support."
OFF
)
IF
(
NEKTAR_USE_HDF5
)
IF
(
NOT NEKTAR_USE_MPI
)
MESSAGE
(
FATAL_ERROR
"HDF5 requires Nektar++ to be configured with "
"NEKTAR_USE_MPI for MPI support."
)
ENDIF
()
# Try to find parallel system HDF5 first.
SET
(
HDF5_PREFER_PARALLEL ON
)
FIND_PACKAGE
(
HDF5 QUIET
)
IF
(
HDF5_FOUND AND NOT HDF5_IS_PARALLEL
)
MESSAGE
(
STATUS
"Non-parallel system HDF5 detected: will build instead."
)
SET
(
BUILD_HDF5 ON
)
ELSEIF
(
HDF5_FOUND
)
SET
(
BUILD_HDF5 OFF
)
ELSE
()
SET
(
BUILD_HDF5 ON
)
ENDIF
()
CMAKE_DEPENDENT_OPTION
(
THIRDPARTY_BUILD_HDF5
"Build HDF5 from ThirdParty"
${
BUILD_HDF5
}
"NEKTAR_USE_HDF5"
OFF
)
IF
(
THIRDPARTY_BUILD_HDF5
)
IF
(
CMAKE_VERSION VERSION_LESS 3.1.0
)
MESSAGE
(
FATAL_ERROR
"HDF5 compilation requires CMake 3.1.0 or later."
)
ENDIF
()
INCLUDE
(
ExternalProject
)
EXTERNALPROJECT_ADD
(
hdf5-1.8.16
PREFIX
${
TPSRC
}
URL
${
TPURL
}
/hdf5-1.8.16.tar.bz2
URL_MD5 79c1593573ebddf734eee8d43ecfe483
STAMP_DIR
${
TPBUILD
}
/stamp
DOWNLOAD_DIR
${
TPSRC
}
SOURCE_DIR
${
TPSRC
}
/hdf5-1.8.16
BINARY_DIR
${
TPBUILD
}
/hdf5-1.8.16
TMP_DIR
${
TPBUILD
}
/hdf5-1.8.16-tmp
INSTALL_DIR
${
TPDIST
}
CONFIGURE_COMMAND
${
CMAKE_COMMAND
}
-G
${
CMAKE_GENERATOR
}
-DCMAKE_C_COMPILER:FILEPATH=
${
CMAKE_C_COMPILER
}
-DCMAKE_CXX_COMPILER:FILEPATH=
${
CMAKE_CXX_COMPILER
}
-DCMAKE_INSTALL_PREFIX:PATH=
${
TPDIST
}
-DHDF5_ENABLE_PARALLEL=ON
-DHDF5_BUILD_CPP_LIB=OFF
-DBUILD_TESTING=OFF