OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-07-07 04:53:03 -05:00
Code Issues Packages Projects Releases Wiki Activity
2d32fde1c9
opm-simulators/CMakeLists.txt

373 lines
12 KiB
CMake
Raw Normal View History

Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
###########################################################################
# #
# Note: The bulk of the build system is located in the cmake/ directory. #
# This file only contains the specializations for this particular #
# project. Most likely you are interested in editing one of these #
# files instead: #
# #
# dune.module Name and version number #
# CMakeLists_files.cmake Path of source files #
# cmake/Modules/${project}-prereqs.cmake Dependencies #
# #
###########################################################################
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Introduced mandatory call to project in top level CMakeLists.txt Somehow this was never called in the OPM modules. But the CMake documentation actually says: "The top-level ``CMakeLists.txt`` file for a project must contain a literal, direct call to the ``project()`` command; loading one through the ``include()`` command is not sufficient. If no such call exists CMake will implicitly add one to the top that enables the default languages (``C`` and ``CXX``). " Without it some variables (like CMAKE_PROJECT_NAME) are not correctly defined.
2017-09-15 04:17:40 -05:00
# Mandatory call to project
Added cusparseSolver. Automatically compiled when CUDA is detected. Must be enabled at runtime by adding '--use-gpu=true'
2019-12-03 07:10:21 -06:00
changed: put prereqs in module itself
2017-12-19 05:44:24 -06:00
project(opm-simulators C CXX)
Introduced mandatory call to project in top level CMakeLists.txt Somehow this was never called in the OPM modules. But the CMake documentation actually says: "The top-level ``CMakeLists.txt`` file for a project must contain a literal, direct call to the ``project()`` command; loading one through the ``include()`` command is not sufficient. If no such call exists CMake will implicitly add one to the top that enables the default languages (``C`` and ``CXX``). " Without it some variables (like CMAKE_PROJECT_NAME) are not correctly defined.
2017-09-15 04:17:40 -05:00
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
cmake_minimum_required (VERSION 2.8)
Added cusparseSolver. Automatically compiled when CUDA is detected. Must be enabled at runtime by adding '--use-gpu=true'
2019-12-03 07:10:21 -06:00
added: look for opm-cmake in sibling directory
2015-05-27 04:51:28 -05:00
option(SIBLING_SEARCH "Search for other modules in sibling directories?" ON)
Set OpenMP default to off
2015-10-19 08:21:08 -05:00
set( USE_OPENMP_DEFAULT OFF ) # Use of OpenMP is considered experimental
add cmake build switches to enable/disable flow and/or ebos
2019-03-06 04:54:21 -06:00
option(BUILD_FLOW "Build the production oriented flow simulator?" ON)
[feature][flow_blackoil] Added a variant to compile the blackoil option only for faster development.
2020-02-07 07:36:22 -06:00
option(BUILD_FLOW_BLACKOIL_ONLY "Build the production oriented flow simulator only supporting the blackoil model?" OFF)
Do not build the extra Flow variants by default.
2019-10-11 01:46:17 -05:00
option(BUILD_FLOW_VARIANTS "Build the variants for flow by default?" OFF)
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
option(BUILD_EBOS "Build the research oriented ebos simulator?" ON)
option(BUILD_EBOS_EXTENSIONS "Build the variants for various extensions of ebos by default?" OFF)
add an ebos variant which uses completely different numbering for phases and components for some reason, this yields quite different results for norne than the default variant, e.g. when comparing PRESSURE, we get ``` > compareECL -k PRESSURE -t UNRST ebos/NORNE_ATW2013 ebos_altidx/NORNE_ATW2013 1 1e-4 Comparing 'ebos/NORNE_ATW2013' to 'ebos_altidx/NORNE_ATW2013'. Comparing PRESSURE... Occurrence in first file = 9 Occurrence in second file = 9 Value index = 0 (first value, second value) = (254.195, 253.191) Program threw an exception: [/home/and/src/opm-common/build-cmake/fake-src/examples/test_util/EclRegressionTest.cpp:161] Deviations exceed tolerances. The absolute deviation is 1.00311, and the tolerance limit is 1. The relative deviation is 0.00394624, and the tolerance limit is 0.0001. ``` IMO this is a bug, but the reasons for it are currently unknown.
2019-03-11 10:50:47 -05:00
option(BUILD_EBOS_DEBUG_EXTENSIONS "Build the ebos variants which are purely for debugging by default?" OFF)
Changed logic for finding cmake modules
2015-03-18 08:26:29 -05:00
Simulate with only active cells (#2213) Use FieldProps implementation for 3D properties
2020-01-13 08:46:50 -06:00
option(ENABLE_3DPROPS_TESTING "Build and use the new experimental 3D properties" OFF)
if (ENABLE_3DPROPS_TESTING)
add_definitions(-DENABLE_3DPROPS_TESTING)
endif()
Drop support for OPM_COMMON_ROOT. Users should either rely in sibling search, use opm-common_DIR, or set CMAKE_PREFIX_PATH correctly to find opm-common.
2017-09-25 05:24:15 -05:00
if(SIBLING_SEARCH AND NOT opm-common_DIR)
# guess the sibling dir
get_filename_component(_leaf_dir_name ${PROJECT_BINARY_DIR} NAME)
get_filename_component(_parent_full_dir ${PROJECT_BINARY_DIR} DIRECTORY)
get_filename_component(_parent_dir_name ${_parent_full_dir} NAME)
#Try if <module-name>/<build-dir> is used
get_filename_component(_modules_dir ${_parent_full_dir} DIRECTORY)
if(IS_DIRECTORY ${_modules_dir}/opm-common/${_leaf_dir_name})
set(opm-common_DIR ${_modules_dir}/opm-common/${_leaf_dir_name})
Added warning if opm-common_DIR is not an existing directory.
2017-09-15 04:34:22 -05:00
else()
Drop support for OPM_COMMON_ROOT. Users should either rely in sibling search, use opm-common_DIR, or set CMAKE_PREFIX_PATH correctly to find opm-common.
2017-09-25 05:24:15 -05:00
string(REPLACE ${PROJECT_NAME} opm-common _opm_common_leaf ${_leaf_dir_name})
if(NOT _leaf_dir_name STREQUAL _opm_common_leaf
AND IS_DIRECTORY ${_parent_full_dir}/${_opm_common_leaf})
# We are using build directories named <prefix><module-name><postfix>
set(opm-common_DIR ${_parent_full_dir}/${_opm_common_leaf})
elseif(IS_DIRECTORY ${_parent_full_dir}/opm-common)
# All modules are in a common build dir
fixed: remove erroneous brace
2018-02-05 04:38:07 -06:00
set(opm-common_DIR "${_parent_full_dir}/opm-common")
Added warning if opm-common_DIR is not an existing directory.
2017-09-15 04:34:22 -05:00
endif()
Drop support for OPM_COMMON_ROOT. Users should either rely in sibling search, use opm-common_DIR, or set CMAKE_PREFIX_PATH correctly to find opm-common.
2017-09-25 05:24:15 -05:00
endif()
Got rid of false warning for empty opm_common_DIR.
2017-09-26 09:16:41 -05:00
endif()
if(opm-common_DIR AND NOT IS_DIRECTORY ${opm-common_DIR})
message(WARNING "Value ${opm-common_DIR} passed to variable"
" opm-common_DIR is not a directory")
Drop support for OPM_COMMON_ROOT. Users should either rely in sibling search, use opm-common_DIR, or set CMAKE_PREFIX_PATH correctly to find opm-common.
2017-09-25 05:24:15 -05:00
endif()
Changed logic for finding cmake modules
2015-03-18 08:26:29 -05:00
Drop support for OPM_COMMON_ROOT. Users should either rely in sibling search, use opm-common_DIR, or set CMAKE_PREFIX_PATH correctly to find opm-common.
2017-09-25 05:24:15 -05:00
find_package(opm-common REQUIRED)
Changed logic for finding cmake modules
2015-03-18 08:26:29 -05:00
Drop support for OPM_COMMON_ROOT. Users should either rely in sibling search, use opm-common_DIR, or set CMAKE_PREFIX_PATH correctly to find opm-common.
2017-09-25 05:24:15 -05:00
include(OpmInit)
Fix policy warnings (needed by OPM/opm-common#1675
2020-04-02 13:31:54 -05:00
OpmSetPolicies()
Try to find opm-data and run flow on SPE1 case.
2015-10-21 10:35:44 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
# not the same location as most of the other projects? this hook overrides
macro (dir_hook)
endmacro (dir_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
# project information is in dune.module. Read this file and set variables.
# we cannot generate dune.module since it is read by dunecontrol before
# the build starts, so it makes sense to keep the data there then.
include (OpmInit)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
use opm-tests
2018-03-12 09:37:21 -05:00
# Look for the opm-tests repository; if found the variable
# HAVE_OPM_TESTS will be set to true.
include(Findopm-tests)
Try to find opm-data and run flow on SPE1 case.
2015-10-21 10:35:44 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
# list of prerequisites for this particular project; this is in a
# separate file (in cmake/Modules sub-directory) because it is shared
# with the find module
Removed .cmake extension from include()
2015-05-15 08:43:03 -05:00
include ("${project}-prereqs")
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
# Make sure we are using the same compiler underneath
# NVCC as for the rest. In the case that NVCC does not support
# that compiler it will error out. Unfortunately this will only
Fix CMake CUDA documentation.
2020-04-29 06:28:23 -05:00
# work for CMake >= 3.8. We found no way to make FindCUDA.cmake error
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
# out. It seems to ignore CMAKE_NVCC_FLAGS and CMAKE. Additionally
# our way of specifying cuda source files never worked for CMake
# version < 3.8. Hence we deactivate cuda for these versions.
# We use "CMAKE_VERSION VERSION_GREATER 3.7.9" instead of
# CMAKE_VERSION VERSION_GREATER_EQUAL 3.8, because of backwards
# compatibility to cmake 3.6 and lower.
if(NOT CMAKE_DISABLE_FIND_PACKAGE_CUDA AND
CMAKE_VERSION VERSION_GREATER 3.7.9)
Use CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE} if appropriate.
2020-04-27 15:01:46 -05:00
if(CMAKE_BUILD_TYPE)
set(_flags_suffix "_${CMAKE_BUILD_TYPE}")
endif()
Use CMAKE_CUDA_HOST_COMPILER instead of ENV{CUDAHOSTCXX}.
2020-04-29 06:27:04 -05:00
if(NOT DEFINED ENV{CUDAHOSTCXX} AND NOT DEFINED CMAKE_CUDA_HOST_COMPILER AND
Use CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE} if appropriate.
2020-04-27 15:01:46 -05:00
(NOT CMAKE_CUDA_FLAGS${_flags_suffix} OR NOT CMAKE_CUDA_FLAGS${_flags_suffix} MATCHES ".*-ccbin .*"))
Use CMAKE_CUDA_HOST_COMPILER instead of ENV{CUDAHOSTCXX}.
2020-04-29 06:27:04 -05:00
message(STATUS "Setting CUDA host compiler CMAKE_CUDA_HOST_COMPILER to ${CMAKE_CXX_COMPILER} to "
Prevent Cmake error for CUDA with incompatible c++. At least on Debian 10 the standard c++ compiler is g++-8, but CUDA only supports g++-7 and our test for CUDA in cmake did send an error in that case/combination which is quite annoying. The reason was that check_language(CUDA) did not honor the CMAKE_CUDA_FLAGS variable and always used the default g++7, but enable_language(CUDA) did honor it. As we do set the underlying host compiler the fromer reported that CUDA is available while the latter marked the CUDA compiler as broken. With this commit we work around this by setting the environment variable ENV{CUDAHOSTCXX} which nvcc will use. Hence now we only try to enable CUDA if it is compatible with the C++ compiler
2020-04-27 07:54:08 -05:00
"prevent incompatibilities. Note that this might report that there "
"is not CUDA compiler if your system's CUDA compiler does not support "
"${CMAKE_CXX_COMPILER}.")
Fix CMake CUDA documentation.
2020-04-29 06:28:23 -05:00
# check_language does not seem to care about ${CMAKE_CUDA_FLAGS} or $(CUDA_NVCC_FLAGS}.
# Hence we set CMAKE_CUDA_HOST_COMPILER to our C++ compiler.
# In check_language(CUDA) we will get an error if we in addition put
# "-ccbin ${CMAKE_CXX_COMPILER}" into CMAKE_CUDA_FLAGS. It results
Prevent multiple "-ccbin g++" in nvcc command. If ENV{CUDAHOSTCXX} is set then this will cause CMake to add "-ccnin ${ENV{CUDAHOSTCXX}}" to variable CMAKE_CUDA_FLAGS even if there already is one.
2020-04-27 14:52:41 -05:00
# in "${NVCC} -ccbin=${CMAKE_CXX_COMPILER} -ccbin ${CMAKE_CXX_COMPILER}"
Fix CMake CUDA documentation.
2020-04-29 06:28:23 -05:00
# which causes nvcc to abort
Use CMAKE_CUDA_HOST_COMPILER instead of ENV{CUDAHOSTCXX}.
2020-04-29 06:27:04 -05:00
set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
endif()
include(CheckLanguage)
check_language(CUDA)
if(CMAKE_CUDA_COMPILER)
Fix CMake CUDA documentation.
2020-04-29 06:28:23 -05:00
# OPTIONAL is ignored. Hence the magic above to check whether enabling CUDA works
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
enable_language(CUDA OPTIONAL)
Prevent Cmake error for CUDA with incompatible c++. At least on Debian 10 the standard c++ compiler is g++-8, but CUDA only supports g++-7 and our test for CUDA in cmake did send an error in that case/combination which is quite annoying. The reason was that check_language(CUDA) did not honor the CMAKE_CUDA_FLAGS variable and always used the default g++7, but enable_language(CUDA) did honor it. As we do set the underlying host compiler the fromer reported that CUDA is available while the latter marked the CUDA compiler as broken. With this commit we work around this by setting the environment variable ENV{CUDAHOSTCXX} which nvcc will use. Hence now we only try to enable CUDA if it is compatible with the C++ compiler
2020-04-27 07:54:08 -05:00
# While the documentation says that it is deprecated, FindCUDA seems the
# only easy way to determine the cublas and cusparse libraries.
# Hence we call it unconditionally
# The WellContributions kernel uses __shfl_down_sync, which was introduced in CUDA 9.0
find_package(CUDA)
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
endif()
Only warn abou CUDA version if CUDA was actually found.
2020-04-15 07:21:36 -05:00
if(CUDA_FOUND AND CUDA_VERSION VERSION_LESS "9.0")
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
set(CUDA_FOUND OFF)
message(WARNING "Deactivating CUDA as we require version 9.0 or newer."
" Found only CUDA version ${CUDA_VERSION}.")
endif()
endif()
if(CUDA_FOUND)
set(HAVE_CUDA 1)
include_directories(${CUDA_INCLUDE_DIRS})
endif()
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
# read the list of components from this file (in the project directory);
# it should set various lists with the names of the files to include
include (CMakeLists_files.cmake)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (config_hook)
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
opm_need_version_of ("dune-common")
opm_need_version_of ("dune-istl")
the version information of opm-fem is needed.
2019-10-22 05:49:06 -05:00
if(dune-fem_FOUND)
opm_need_version_of ("dune-fem")
endif()
changed: rename ewoms to opm-models
2019-08-23 01:34:32 -05:00
opm_need_version_of ("opm-models")
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
endmacro (config_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (prereqs_hook)
endmacro (prereqs_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (sources_hook)
endmacro (sources_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (fortran_hook)
endmacro (fortran_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
added: hook for conditionally compiled files backport from opm-upscaling PR#100
2014-06-16 07:40:52 -05:00
macro (files_hook)
endmacro (files_hook)
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (tests_hook)
endmacro (tests_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
# all setup common to the OPM library modules is done here
include (OpmLibMain)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
use opm-tests
2018-03-12 09:37:21 -05:00
if (HAVE_OPM_TESTS)
Remove python tests.
2016-11-21 11:02:21 -06:00
include (${CMAKE_CURRENT_SOURCE_DIR}/compareECLFiles.cmake)
changed: move multisegment well test to proper regression test
2017-03-03 08:08:12 -06:00
endif()
added: install bash tab completion for flow
2018-09-19 04:45:40 -05:00
Run the "gatherconvergencereport" test in parallel.
2018-11-13 03:28:05 -06:00
opm_set_test_driver(${CMAKE_CURRENT_SOURCE_DIR}/tests/run-parallel-unitTest.sh "")
opm_add_test(test_gatherconvergencereport
DEPENDS "opmsimulators"
LIBRARIES opmsimulators ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}
SOURCES
tests/test_gatherconvergencereport.cpp
CONDITION
disable building of tests if Boost::test is not found
2020-02-19 05:28:55 -06:00
MPI_FOUND AND Boost_UNIT_TEST_FRAMEWORK_FOUND
Run the "gatherconvergencereport" test in parallel.
2018-11-13 03:28:05 -06:00
DRIVER_ARGS
fixed: use PROJECT_BINARY_DIR, not CMAKE_BINARY_DIR tests fail to execute in super-build otherwise
2020-04-21 01:50:51 -05:00
5 ${PROJECT_BINARY_DIR}
Run the "gatherconvergencereport" test in parallel.
2018-11-13 03:28:05 -06:00
)
gather deferredLogger implemented
2019-01-11 06:53:18 -06:00
opm_add_test(test_gatherdeferredlogger
DEPENDS "opmsimulators"
LIBRARIES opmsimulators ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}
SOURCES
tests/test_gatherdeferredlogger.cpp
CONDITION
disable building of tests if Boost::test is not found
2020-02-19 05:28:55 -06:00
MPI_FOUND AND Boost_UNIT_TEST_FRAMEWORK_FOUND
gather deferredLogger implemented
2019-01-11 06:53:18 -06:00
DRIVER_ARGS
fixed: use PROJECT_BINARY_DIR, not CMAKE_BINARY_DIR tests fail to execute in super-build otherwise
2020-04-21 01:50:51 -05:00
5 ${PROJECT_BINARY_DIR}
gather deferredLogger implemented
2019-01-11 06:53:18 -06:00
)
add cmake build switches to enable/disable flow and/or ebos
2019-03-06 04:54:21 -06:00
include(OpmBashCompletion)
gather deferredLogger implemented
2019-01-11 06:53:18 -06:00
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
if (NOT BUILD_FLOW)
set(FLOW_DEFAULT_ENABLE_IF "FALSE")
else()
set(FLOW_DEFAULT_ENABLE_IF "TRUE")
endif()
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
# the production oriented general-purpose ECL simulator
make the build of flow fully parallelizable so far, the actual specializations of the simulator were compiled into the `libopmsimulators` library and the build of the glue code (`flow.cpp`) thus needed to be deferred until the library was fully built. Since the compilation of the glue code requires a full property hierarchy for handling command line parameters, this arrangement significantly increases the build time for systems with a sufficient number of parallel build processes. ("sufficient" here means 8 or more threads, i.e., a quadcore system with hyperthreading is sufficient provided that it has enough main memory.) the new approach is not to include these objects in `libopmsimulators`, but to directly deal with them in the `flow` binary. this allows all of them and the glue code to be compiled in parallel. compilation time on my machine before this change: ``` > touch ../opm/autodiff/BlackoilModelEbos.hpp; time make -j32 flow 2> /dev/null Scanning dependencies of target opmsimulators [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_gasoil.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_oilwater.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_blackoil.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_solvent.cpp.o [ 4%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_polymer.cpp.o [ 6%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_energy.cpp.o [ 6%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_oilwater_polymer.cpp.o [ 6%] Linking CXX static library lib/libopmsimulators.a [ 97%] Built target opmsimulators Scanning dependencies of target flow [100%] Building CXX object CMakeFiles/flow.dir/examples/flow.cpp.o [100%] Linking CXX executable bin/flow [100%] Built target flow real 1m45.692s user 8m47.195s sys 0m11.533s ``` after: ``` > touch ../opm/autodiff/BlackoilModelEbos.hpp; time make -j32 flow 2> /dev/null [ 91%] Built target opmsimulators Scanning dependencies of target flow [ 93%] Building CXX object CMakeFiles/flow.dir/flow/flow.cpp.o [ 95%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_gasoil.cpp.o [ 97%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_oilwater_polymer.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_polymer.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_oilwater.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_solvent.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_blackoil.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_energy.cpp.o [100%] Linking CXX executable bin/flow [100%] Built target flow real 1m21.597s user 8m49.476s sys 0m10.973s ``` (this corresponds to a ~20% reduction of the time spend on waiting for the compiler.)
2018-09-20 03:58:27 -05:00
opm_add_test(flow
ONLY_COMPILE
ALWAYS_ENABLE
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
DEFAULT_ENABLE_IF ${FLOW_DEFAULT_ENABLE_IF}
make the build of flow fully parallelizable so far, the actual specializations of the simulator were compiled into the `libopmsimulators` library and the build of the glue code (`flow.cpp`) thus needed to be deferred until the library was fully built. Since the compilation of the glue code requires a full property hierarchy for handling command line parameters, this arrangement significantly increases the build time for systems with a sufficient number of parallel build processes. ("sufficient" here means 8 or more threads, i.e., a quadcore system with hyperthreading is sufficient provided that it has enough main memory.) the new approach is not to include these objects in `libopmsimulators`, but to directly deal with them in the `flow` binary. this allows all of them and the glue code to be compiled in parallel. compilation time on my machine before this change: ``` > touch ../opm/autodiff/BlackoilModelEbos.hpp; time make -j32 flow 2> /dev/null Scanning dependencies of target opmsimulators [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_gasoil.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_oilwater.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_blackoil.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_solvent.cpp.o [ 4%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_polymer.cpp.o [ 6%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_energy.cpp.o [ 6%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_oilwater_polymer.cpp.o [ 6%] Linking CXX static library lib/libopmsimulators.a [ 97%] Built target opmsimulators Scanning dependencies of target flow [100%] Building CXX object CMakeFiles/flow.dir/examples/flow.cpp.o [100%] Linking CXX executable bin/flow [100%] Built target flow real 1m45.692s user 8m47.195s sys 0m11.533s ``` after: ``` > touch ../opm/autodiff/BlackoilModelEbos.hpp; time make -j32 flow 2> /dev/null [ 91%] Built target opmsimulators Scanning dependencies of target flow [ 93%] Building CXX object CMakeFiles/flow.dir/flow/flow.cpp.o [ 95%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_gasoil.cpp.o [ 97%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_oilwater_polymer.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_polymer.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_oilwater.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_solvent.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_blackoil.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_energy.cpp.o [100%] Linking CXX executable bin/flow [100%] Built target flow real 1m21.597s user 8m49.476s sys 0m10.973s ``` (this corresponds to a ~20% reduction of the time spend on waiting for the compiler.)
2018-09-20 03:58:27 -05:00
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators"
SOURCES
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
flow/flow.cpp
flow/flow_ebos_blackoil.cpp
flow/flow_ebos_gasoil.cpp
flow/flow_ebos_oilwater.cpp
flow/flow_ebos_polymer.cpp
Use foam module.
2019-04-26 03:38:37 -05:00
flow/flow_ebos_foam.cpp
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 10:48:17 -06:00
flow/flow_ebos_brine.cpp
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
flow/flow_ebos_solvent.cpp
flow/flow_ebos_energy.cpp
flow/flow_ebos_oilwater_polymer.cpp
flow/flow_ebos_oilwater_polymer_injectivity.cpp)
[feature][flow_blackoil] Added a variant to compile the blackoil option only for faster development.
2020-02-07 07:36:22 -06:00
if (NOT BUILD_FLOW_BLACKOIL_ONLY)
set(FLOW_BLACKOIL_ONLY_DEFAULT_ENABLE_IF "FALSE")
else()
set(FLOW_BLACKOIL_ONLY_DEFAULT_ENABLE_IF "TRUE")
endif()
# the production oriented general-purpose ECL simulator
opm_add_test(flow_blackoil
ONLY_COMPILE
ALWAYS_ENABLE
DEFAULT_ENABLE_IF ${FLOW_BLACKOIL_ONLY_DEFAULT_ENABLE_IF}
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators"
SOURCES
flow/flow.cpp
flow/flow_ebos_blackoil.cpp)
target_compile_definitions(flow_blackoil PRIVATE "FLOW_BLACKOIL_ONLY")
Do not build the extra Flow variants by default.
2019-10-11 01:46:17 -05:00
if (NOT BUILD_FLOW_VARIANTS)
set(FLOW_VARIANTS_DEFAULT_ENABLE_IF "FALSE")
else()
set(FLOW_VARIANTS_DEFAULT_ENABLE_IF "TRUE")
endif()
# Variant versions of Flow.
Version of cpr amg which can reuse setup and also change smoothers of fine and coarse system by changing tags
2019-03-21 16:15:22 -05:00
opm_add_test(flow_blackoil_dunecpr
ONLY_COMPILE
Do not build the extra Flow variants by default.
2019-10-11 01:46:17 -05:00
DEFAULT_ENABLE_IF ${FLOW_VARIANTS_DEFAULT_ENABLE_IF}
Version of cpr amg which can reuse setup and also change smoothers of fine and coarse system by changing tags
2019-03-21 16:15:22 -05:00
SOURCES flow/flow_blackoil_dunecpr.cpp
EXE_NAME flow_blackoil_dunecpr
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
Add two new flow variants for one-phase (water, water+energy) simulation.
2019-10-10 09:14:44 -05:00
opm_add_test(flow_onephase
ONLY_COMPILE
Do not build the extra Flow variants by default.
2019-10-11 01:46:17 -05:00
DEFAULT_ENABLE_IF ${FLOW_VARIANTS_DEFAULT_ENABLE_IF}
Add two new flow variants for one-phase (water, water+energy) simulation.
2019-10-10 09:14:44 -05:00
SOURCES flow/flow_onephase.cpp
EXE_NAME flow_onephase
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
opm_add_test(flow_onephase_energy
ONLY_COMPILE
Do not build the extra Flow variants by default.
2019-10-11 01:46:17 -05:00
DEFAULT_ENABLE_IF ${FLOW_VARIANTS_DEFAULT_ENABLE_IF}
Add two new flow variants for one-phase (water, water+energy) simulation.
2019-10-10 09:14:44 -05:00
SOURCES flow/flow_onephase_energy.cpp
EXE_NAME flow_onephase_energy
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
if (BUILD_FLOW)
install(TARGETS flow DESTINATION bin)
opm_add_bash_completion(flow)
add_test(NAME flow__version
COMMAND flow --version)
set_tests_properties(flow__version PROPERTIES
PASS_REGULAR_EXPRESSION "${${project}_LABEL}")
add cmake build switches to enable/disable flow and/or ebos
2019-03-06 04:54:21 -06:00
endif()
Add cmake test for the --version switch
2018-12-09 14:15:59 -06:00
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
if (NOT BUILD_EBOS)
set(EBOS_DEFAULT_ENABLE_IF "FALSE")
else()
set(EBOS_DEFAULT_ENABLE_IF "TRUE")
endif()
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
# the research oriented general-purpose ECL simulator ("ebos" == &ecl
# &black-&oil &simulator)
enable the foam extension for ebos/mebos
2019-08-09 04:04:45 -05:00
set(MEBOS_TARGETS "")
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 10:48:17 -06:00
foreach(OBJ blackoil solvent polymer foam brine gasoil oilwater oilwaterpolymer thermal)
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
add_library(ebos_lib${OBJ} OBJECT EXCLUDE_FROM_ALL ebos/ebos_${OBJ}.cc)
enable the foam extension for ebos/mebos
2019-08-09 04:04:45 -05:00
list(APPEND MEBOS_TARGETS $<TARGET_OBJECTS:ebos_lib${OBJ}>)
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
endforeach()
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
opm_add_test(ebos
fix the default build system for some reason, libraries produced for a module are not linked to the executables of the module by the default build system. so far this did not matter for `ebos` but with this PR, it starts using stuff from `libopmsimulators`...
2019-03-04 08:38:07 -06:00
ONLY_COMPILE
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
DEFAULT_ENABLE_IF ${EBOS_DEFAULT_ENABLE_IF}
fix the default build system for some reason, libraries produced for a module are not linked to the executables of the module by the default build system. so far this did not matter for `ebos` but with this PR, it starts using stuff from `libopmsimulators`...
2019-03-04 08:38:07 -06:00
ALWAYS_ENABLE
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
EXE_NAME ebos
LIBRARIES opmsimulators
SOURCES ebos/ebos_main.cc $<TARGET_OBJECTS:ebos_libblackoil>)
Add cmake test for the --version switch
2018-12-09 14:15:59 -06:00
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
if (BUILD_EBOS)
install(TARGETS ebos DESTINATION bin)
opm_add_bash_completion(ebos)
endif()
if (NOT BUILD_EBOS_EXTENSIONS)
set(EBOS_EXTENSIONS_DEFAULT_ENABLE_IF "FALSE")
else()
set(EBOS_EXTENSIONS_DEFAULT_ENABLE_IF "TRUE")
endif()
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 10:48:17 -06:00
foreach(OBJ solvent polymer foam brine gasoil oilwater oilwaterpolymer thermal)
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
opm_add_test(ebos_${OBJ}
ONLY_COMPILE
DEFAULT_ENABLE_IF ${EBOS_EXTENSIONS_DEFAULT_ENABLE_IF}
SOURCES ebos/ebos_${OBJ}_main.cc $<TARGET_OBJECTS:ebos_lib${OBJ}>
EXE_NAME ebos_${OBJ}
LIBRARIES opmsimulators)
endforeach()
add `mebos`, a multiplexed ebos variant `mebos` works similarly as `flow`, but in contrast to `flow`, `mebos` only creates the deck in the common code path whilst the 'EclipseState' and the other higher-level parser objects are always created internally by the vanguard. this approach avoids code duplication and the worst effects of parser API creep. to avoid having to compile non-trivial compile units multiple times, the actual code of the variants is moved into `ebos_$VARIANT.{hh,cc}` files and the respective compile units are each put into a small static library whilst the main function of said libraries are invoked by either the multiplexed or the respective specialized simulator's `main()`. This is also somewhat similar of how `flow` works, with the difference that `mebos` uses the blackoil variant to determine the parameters it needs to know for parsing the deck instead of introducing a "fake" type tag for this. The rationale is to reduce compile time compared to the "fake type tag" approach and -- to a lesser extend -- avoid unnecessary copy-and-pasting of code. In particular, this means that for the vast majority of cases, only one place needs changed in the code for all `ebos` variants if, for example, the parser API requires further objects in the future.
2019-06-11 03:22:11 -05:00
opm_add_test(mebos
ONLY_COMPILE
DEFAULT_ENABLE_IF ${EBOS_EXTENSIONS_DEFAULT_ENABLE_IF}
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
SOURCES ebos/mebos_main.cc
enable the foam extension for ebos/mebos
2019-08-09 04:04:45 -05:00
${MEBOS_TARGETS}
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
EXE_NAME mebos
LIBRARIES opmsimulators)
add some ebos variants these variants should cover most of the common use cases. That said, there are no plans to provide simulators for combinations of blackoil extensions or a "multiplexing" simulator like `flow`: If someone is interested in e.g., an oil-water simulator with polymer and energy enabled, a separate self-compiled executable should be added locally.
2019-03-05 04:41:02 -06:00
add an ebos variant which uses completely different numbering for phases and components for some reason, this yields quite different results for norne than the default variant, e.g. when comparing PRESSURE, we get ``` > compareECL -k PRESSURE -t UNRST ebos/NORNE_ATW2013 ebos_altidx/NORNE_ATW2013 1 1e-4 Comparing 'ebos/NORNE_ATW2013' to 'ebos_altidx/NORNE_ATW2013'. Comparing PRESSURE... Occurrence in first file = 9 Occurrence in second file = 9 Value index = 0 (first value, second value) = (254.195, 253.191) Program threw an exception: [/home/and/src/opm-common/build-cmake/fake-src/examples/test_util/EclRegressionTest.cpp:161] Deviations exceed tolerances. The absolute deviation is 1.00311, and the tolerance limit is 1. The relative deviation is 0.00394624, and the tolerance limit is 0.0001. ``` IMO this is a bug, but the reasons for it are currently unknown.
2019-03-11 10:50:47 -05:00
if (NOT BUILD_EBOS_DEBUG_EXTENSIONS)
set(EBOS_DEBUG_EXTENSIONS_DEFAULT_ENABLE_IF "FALSE")
else()
set(EBOS_DEBUG_EXTENSIONS_DEFAULT_ENABLE_IF "TRUE")
endif()
opm_add_test(ebos_altidx
ONLY_COMPILE
DEFAULT_ENABLE_IF ${EBOS_DEBUG_EXTENSIONS_DEFAULT_ENABLE_IF}
SOURCES ebos/ebos_altidx.cc
EXE_NAME ebos_altidx
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
DEPENDS opmsimulators
LIBRARIES opmsimulators)
add an ebos variant which uses completely different numbering for phases and components for some reason, this yields quite different results for norne than the default variant, e.g. when comparing PRESSURE, we get ``` > compareECL -k PRESSURE -t UNRST ebos/NORNE_ATW2013 ebos_altidx/NORNE_ATW2013 1 1e-4 Comparing 'ebos/NORNE_ATW2013' to 'ebos_altidx/NORNE_ATW2013'. Comparing PRESSURE... Occurrence in first file = 9 Occurrence in second file = 9 Value index = 0 (first value, second value) = (254.195, 253.191) Program threw an exception: [/home/and/src/opm-common/build-cmake/fake-src/examples/test_util/EclRegressionTest.cpp:161] Deviations exceed tolerances. The absolute deviation is 1.00311, and the tolerance limit is 1. The relative deviation is 0.00394624, and the tolerance limit is 0.0001. ``` IMO this is a bug, but the reasons for it are currently unknown.
2019-03-11 10:50:47 -05:00
add ebos_plain to the ebos debug extensions
2019-06-03 04:11:41 -05:00
opm_add_test(ebos_plain
ONLY_COMPILE
DEFAULT_ENABLE_IF ${EBOS_DEBUG_EXTENSIONS_DEFAULT_ENABLE_IF}
SOURCES ebos/ebos_plain.cc
EXE_NAME ebos_plain
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
DEPENDS opmsimulators
LIBRARIES opmsimulators)
add but do not build disabled targets this simply excludes the disabled simulators from `make all` while `make flow` will continue to work even if the cmake variable `BUILD_FLOW` was set to `OFF`. This requires a small patch for opm-common.
2019-03-07 05:45:15 -06:00
if (BUILD_EBOS_EXTENSIONS)
remove depricated ebos_saltwater from install list
2020-01-09 03:18:46 -06:00
foreach(TGT ebos_solvent ebos_polymer ebos_foam ebos_brine ebos_gasoil ebos_oilwater ebos_oilwaterpolymer ebos_thermal mebos)
changed: simplify buildsystem a little - use loops instead of copy-paste - use object libraries to avoid some unnecessary archives - tab scrubbing
2019-06-13 07:59:31 -05:00
install(TARGETS ${TGT} DESTINATION bin)
opm_add_bash_completion(${TGT})
endforeach()
add cmake build switches to enable/disable flow and/or ebos
2019-03-06 04:54:21 -06:00
endif()
Add python folder to top-level CMakeLists.
2019-10-31 10:41:13 -05:00
if (OPM_ENABLE_PYTHON)
add_subdirectory(python)
endif()
clean-up after rebase
2020-01-09 02:32:24 -06:00
add norne and norne_parallel as ExtraTests to execute these you have to use ctest -C ExtraTests or 'make extra_test'
2020-04-03 03:15:49 -05:00
add_custom_target(extra_test ${CMAKE_CTEST_COMMAND} -C ExtraTests)
clean-up after rebase
2020-01-09 02:32:24 -06:00
# must link libraries after target 'flow' has been defined
if(CUDA_FOUND)
Make mixing incompatible host compiler/device compiler versions fail. We experienced weired linker errors when using host compiler version for compilation that were not supported by the nvcc used to compile the cuda code: ``` [ 15%] Linking CXX executable bin/test_timer /usr/bin/ld: /home/mblatt/src/dune/opm-2.6/opm-common/opm-seq/lib/libopmcommon.a(Parser.cpp.o): in function `Opm::(anonymous namespace)::file& std::vector<Opm::(anonymous namespace)::file, std::allocator<Opm::(anonymous namespace)::file> >::emplace_back<std::filesystem::__cxx11::path&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>(std::filesystem::__cxx11::path&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&)': Parser.cpp:(.text+0x1096): undefined reference to `std::filesystem::__cxx11::path::_M_split_cmpts()' /usr/bin/ld: Parser.cpp:(.text+0x10ad): undefined reference to `std::filesystem::__cxx11::path::_M_split_cmpts()' /usr/bin/ld: /home/mblatt/src/dune/opm-2.6/opm-common/opm-seq/lib/libopmcommon.a(Parser.cpp.o): in function `Opm::(anonymous namespace)::ParserState::loadFile(std::filesystem::__cxx11::path const&)': Parser.cpp:(.text+0x23a1): undefined reference to `std::filesystem::canonical(std::filesystem::__cxx11::path const&)' /usr/bin/ld: Parser.cpp:(.text+0x24e0): undefined reference to `std::filesystem::__cxx11::path::_M_split_cmpts()' ``` The reason turned out to be that the library path was build up by paths of the old (g++-7) compiler used by nvcc and the actual (newer) compiler g++-8. This completely messed up the linker paths for CMake. To detect this situation already when running cmake we have resorted to first setting the CMAKE_CUDA_FLAGS to force cmake to make nvcc use the host compiler and to activate CUDA (if available) before calling `find_package(CUDA)`. If the host compiler is not supported CMake will error out during `enable(CUDA)` Note that we still use (deprecated) FindCUDA later to determine the libraries to link to. The users has the option to either deactivate CUDA by setting `-DCMAKE_DISABLE_FIND_PACKAGE_CUDA=ON` or to use a compiler supported by nvcc (setting `-DCMAKE_CXX_COMPILER=compiler`). Additionally we do not try to activate CUDA the CMake version is < 3.8. Please note that previously CMake would have errored out here anyway since we used the unsupported `enable_language(CUDA)` even in this case. Closes #2363.
2020-02-25 09:54:53 -06:00
target_link_libraries( opmsimulators PUBLIC ${CUDA_cusparse_LIBRARY} )
target_link_libraries( opmsimulators PUBLIC ${CUDA_cublas_LIBRARY} )
clean-up after rebase
2020-01-09 02:32:24 -06:00
endif()
Reference in New Issue Copy Permalink