OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-11-29 20:43:49 -06:00
Code Issues Packages Projects Releases Wiki Activity
715e0e1c82
opm-simulators/CMakeLists.txt

506 lines
18 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
Stop pretending that we support CMake 2.8 We actually already require at least CMake 2.8.12 due to the embedded pybind11 (some tests of it are even at 3.0). Anyway as Ubuntu LTS has 3.10.2 I doubt that anything less is tested by us.
2021-03-26 03:36:18 -05:00
cmake_minimum_required (VERSION 3.10)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
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)
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)
Make a flow version that uses the polyhedreal grid Currently the simulator creats the polyhedreal grid from an eclGrid from opm-common TODO - make it possible to create the grid directly from DGF or MRST format - fix issue on norne.
2020-11-10 01:54:44 -06:00
option(BUILD_FLOW_POLY_GRID "Build flow blackoil with polyhedral grid" OFF)
add cmake option to disable the python tests due to bugs in the openmpi on bionic, this test fails to execute properly in pbuilder environments. instead of rebuilding openmpi without dynamic loading (which is the suggested fix) and potentially break users systems, this is a non-intrusive workaround to be used for packaging. also add explicit option for python support to make it visible in cmake frontends.
2020-11-18 02:42:39 -06:00
option(OPM_ENABLE_PYTHON "Enable python bindings?" OFF)
option(OPM_ENABLE_PYTHON_TESTS "Enable tests for the python bindings?" ON)
Dynamically update schedule from Python Adds some test cases that show how injection properties in Opm::Schedule can be dynamically modified from Python.
2022-05-18 07:41:13 -05:00
option(OPM_INSTALL_PYTHON "Install python bindings?" ON)
Allow CMake to set CHOW_PATEL variables
2021-10-25 07:57:46 -05:00
option(USE_CHOW_PATEL_ILU "Use the iterative ILU by Chow and Patel?" OFF)
option(USE_CHOW_PATEL_ILU_GPU "Run iterative ILU decomposition on GPU? Requires USE_CHOW_PATEL_ILU" OFF)
Reduced header inclusion and updated comments
2022-02-02 05:06:40 -06:00
option(USE_CHOW_PATEL_ILU_GPU_PARALLEL "Try to use more parallelism on the GPU during the iterative ILU decomposition? Requires USE_CHOW_PATEL_ILU_GPU" OFF)
rebasing
2021-12-01 07:00:21 -06:00
option(BUILD_FLOW_ALU_GRID "Build flow blackoil with alu grid" OFF)
Changes needed to add Damaris functionality. The current state is that we output the pressure field and we use both HDF5 and parallel HDF5. Damaris initialization is added after InitMpi but before starting the simulation. Damaris will invoke a separate core for writing in parallel and leave the rest of cores for the simulator. The main changes are in main where start_damaris and then in eclwriterm where we use damaris to output the PRESSURE. To test Damaris one can use --enable-damaris-output=true and to use parallel HDF5 one can use --enable-async-damaris-output=true (false is the default choice)
2021-10-22 04:09:12 -05:00
option(USE_DAMARIS_LIB "Use the Damaris library for asynchronous I/O?" OFF)
Simulate with only active cells (#2213) Use FieldProps implementation for 3D properties
2020-01-13 08:46:50 -06:00
Dynamically update schedule from Python Adds some test cases that show how injection properties in Opm::Schedule can be dynamically modified from Python.
2022-05-18 07:41:13 -05:00
# The following was copied from CMakeLists.txt in opm-common.
# TODO: factor out the common parts in opm-common and opm-simulator as a cmake module
if (OPM_ENABLE_PYTHON)
# We need to be compatible with older CMake versions
# that do not offer FindPython3
# e.g. Ubuntu LTS 18.04 uses cmake 3.10
if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
find_package(PythonInterp REQUIRED)
if(PYTHON_VERSION_MAJOR LESS 3)
message(SEND_ERROR "OPM requires version 3 of Python but only version ${PYTHON_VERSION_STRING} was found")
endif()
set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
set(Python3_LIBRARIES ${PYTHON_LIBRARIES})
remove faulty brace
2022-07-27 11:26:22 -05:00
set(Python3_VERSION "${PYTHON_VERSION_STRING}")
Make Python opm package a namespace package Convert the Python opm package from a regular package to a namespace package such that opm-simulators and opm-common can contribute to the package from different filesystem paths. In this way, the two packages opm.simulators and opm.io (in opm-common) can have a different parent filesystem path.
2022-06-07 01:29:33 -05:00
set(Python3_VERSION_MINOR ${PYTHON_VERSION_MINOR})
Dynamically update schedule from Python Adds some test cases that show how injection properties in Opm::Schedule can be dynamically modified from Python.
2022-05-18 07:41:13 -05:00
else()
# Be backwards compatible.
if(PYTHON_EXECUTABLE AND NOT Python3_EXECUTABLE)
set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
endif()
Also search for development artifacts We should also search for development artifacts when combining FindPython3.cmake with find_package(pybind11)
2022-05-30 03:59:42 -05:00
find_package(Python3 REQUIRED COMPONENTS Interpreter Development)
Dynamically update schedule from Python Adds some test cases that show how injection properties in Opm::Schedule can be dynamically modified from Python.
2022-05-18 07:41:13 -05:00
endif()
Make Python opm package a namespace package Convert the Python opm package from a regular package to a namespace package such that opm-simulators and opm-common can contribute to the package from different filesystem paths. In this way, the two packages opm.simulators and opm.io (in opm-common) can have a different parent filesystem path.
2022-06-07 01:29:33 -05:00
if(Python3_VERSION_MINOR LESS 3)
# Python native namespace packages requires python >= 3.3
message(SEND_ERROR "OPM requires python >= 3.3 but only version ${Python3_VERSION} was found")
endif()
Dynamically update schedule from Python Adds some test cases that show how injection properties in Opm::Schedule can be dynamically modified from Python.
2022-05-18 07:41:13 -05:00
# Compatibility settings for PythonInterp and PythonLibs
# used e.g. in FindCwrap, pybind11
set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
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})
Need to set ENV{CUDAHOSTCXX}, too. No variables are used by check_language and hence we need ti make nvc aware of the host compiler by the environment variable.
2020-04-29 06:58:48 -05:00
set(ENV{CUDAHOSTCXX} ${CMAKE_CUDA_HOST_COMPILER}) # The only thing honored by check_language(CUDA)!
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)
Combine multiple defines into one
2022-11-17 02:59:49 -06:00
set(COMPILE_BDA_BRIDGE 1)
Move CUDA tests to a later stage to make time for setting policies.
2020-04-02 13:30:20 -05:00
include_directories(${CUDA_INCLUDE_DIRS})
endif()
Added openclSolver Usage: --gpu-mode=[cusparse|opencl|none] on command line
2020-06-22 11:26:49 -05:00
find_package(OpenCL)
if(OpenCL_FOUND)
Use OpenCl's CL/cl2.hpp instead of CL/cl.hpp We still request Standard version 1.2 only. We need to use KernelFunctor instead of make_kernel. In addition cl::Sources now works on std::string and does not support std::pair<const char*, in> anymore.
2021-10-28 09:18:07 -05:00
# the current OpenCL implementation relies on cl2.hpp, not cl.hpp
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
# make sure it is available, otherwise disable OpenCL
Use OpenCl's CL/cl2.hpp instead of CL/cl.hpp We still request Standard version 1.2 only. We need to use KernelFunctor instead of make_kernel. In addition cl::Sources now works on std::string and does not support std::pair<const char*, in> anymore.
2021-10-28 09:18:07 -05:00
find_file(CL2_HPP CL/cl2.hpp HINTS ${OpenCL_INCLUDE_DIRS})
if(CL2_HPP)
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
set(HAVE_OPENCL 1)
Combine multiple defines into one
2022-11-17 02:59:49 -06:00
set(COMPILE_BDA_BRIDGE 1)
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
include_directories(${OpenCL_INCLUDE_DIRS})
changed: probe for cl/opencl.hpp and use if found this to avoid a spam of warnings
2021-11-01 07:45:21 -05:00
find_file(OPENCL_HPP CL/opencl.hpp HINTS ${OpenCL_INCLUDE_DIRS})
if(OPENCL_HPP)
set(HAVE_OPENCL_HPP 1)
endif()
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
else()
Use OpenCl's CL/cl2.hpp instead of CL/cl.hpp We still request Standard version 1.2 only. We need to use KernelFunctor instead of make_kernel. In addition cl::Sources now works on std::string and does not support std::pair<const char*, in> anymore.
2021-10-28 09:18:07 -05:00
message(WARNING " OpenCL was found, but this version of opm-simulators relies on CL/cl2.hpp, which implements OpenCL 1.0, 1.1 and 1.2.\n Deactivating OpenCL")
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
set(OpenCL_FOUND OFF)
Fix CMake variable case bug. This caused compile failure on a system without the c++ OpenCL binding header cl.hpp.
2020-07-28 04:49:01 -05:00
set(OPENCL_FOUND OFF)
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
endif()
Allow CMake to set CHOW_PATEL variables
2021-10-25 07:57:46 -05:00
if(USE_CHOW_PATEL_ILU)
add_compile_options(-DCHOW_PATEL=1)
if(USE_CHOW_PATEL_ILU_GPU)
add_compile_options(-DCHOW_PATEL_GPU=1)
if(USE_CHOW_PATEL_ILU_GPU_PARALLEL)
add_compile_options(-DCHOW_PATEL_GPU_PARALLEL=1)
else()
add_compile_options(-DCHOW_PATEL_GPU_PARALLEL=0)
endif()
else()
add_compile_options(-DCHOW_PATEL_GPU=0)
add_compile_options(-DCHOW_PATEL_GPU_PARALLEL=0)
endif()
endif()
else()
if(USE_CHOW_PATEL_ILU)
message(FATAL_ERROR " CHOW_PATEL_ILU only works for openclSolver, but OpenCL was not found")
endif()
Added openclSolver Usage: --gpu-mode=[cusparse|opencl|none] on command line
2020-06-22 11:26:49 -05:00
endif()
Use CMake config of amgcl itself
2021-06-18 04:46:00 -05:00
find_package(amgcl)
if(amgcl_FOUND)
Added amgclSolverBackend
2021-06-02 09:19:00 -05:00
set(HAVE_AMGCL 1)
Combine multiple defines into one
2022-11-17 02:59:49 -06:00
set(COMPILE_BDA_BRIDGE 1)
Use amgcl::amgcl target, but only extract INTERFACE_INCLUDE_DIRS. There is no AMGCL_INCLUDE_DIRS when using find_package. We now query the target amgcl::amgcl for INTERFACE_INCLUDE_DIRS and store the result in AMGCL_INCLUDE_DIRS. Note that we cannot link amgcl::amgcl target to libopmsimulators as this sets the -fopenmp flag for all the source files and makes compilation with nvcc fail.
2021-06-18 12:40:46 -05:00
# Linking to target angcl::amgcl drags in OpenMP and -fopenmp as a compile
# flag. With that nvcc fails as it does not that flag.
Make sure amgcl can be used without CUDA
2021-06-21 04:13:34 -05:00
# Hence we set AMGCL_INCLUDE_DIRS.
Use amgcl::amgcl target, but only extract INTERFACE_INCLUDE_DIRS. There is no AMGCL_INCLUDE_DIRS when using find_package. We now query the target amgcl::amgcl for INTERFACE_INCLUDE_DIRS and store the result in AMGCL_INCLUDE_DIRS. Note that we cannot link amgcl::amgcl target to libopmsimulators as this sets the -fopenmp flag for all the source files and makes compilation with nvcc fail.
2021-06-18 12:40:46 -05:00
get_property(AMGCL_INCLUDE_DIRS TARGET amgcl::amgcl PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
Prevent warnings form VexCL/amgcl using system include directories.
2021-06-30 09:41:35 -05:00
include_directories(SYSTEM ${AMGCL_INCLUDE_DIRS})
Added amgclSolverBackend
2021-06-02 09:19:00 -05:00
endif()
Search for VexCL and create an imported target. Unfortunately, we cannot us the imported targets. They add some compile parameters using generator expressions based on the CXX_COMPILER_ID. While we are using the system CXX compiler for most of the stuff, some cuda code is compiled with nvcc which at least for some versions does not support -Wno-catch-value (which gets passed as normal compiler option).
2021-06-30 09:03:14 -05:00
if(OpenCL_FOUND)
find_package(VexCL)
if(VexCL_FOUND)
set(HAVE_VEXCL 1)
Combine multiple defines into one
2022-11-17 02:59:49 -06:00
set(COMPILE_BDA_BRIDGE 1)
Search for VexCL and create an imported target. Unfortunately, we cannot us the imported targets. They add some compile parameters using generator expressions based on the CXX_COMPILER_ID. While we are using the system CXX compiler for most of the stuff, some cuda code is compiled with nvcc which at least for some versions does not support -Wno-catch-value (which gets passed as normal compiler option).
2021-06-30 09:03:14 -05:00
# generator expressions in vexcl do not seem to work and therefore
# we cannot use the imported target. Hence we exract the needed info
# from the targets
get_property(VEXCL_INCLUDE_DIRS TARGET VexCL::Common PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
get_property(VEXCL_LINK_LIBRARIES TARGET VexCL::Common PROPERTY INTERFACE_LINK_LIBRARIES)
get_property(VEXCL_COMPILE_DEFINITIONS TARGET VexCL::OpenCL PROPERTY INTERFACE_COMPILE_DEFINITIONS)
set(VEXCL_LINK_LIBRARIES "${VEXCL_LINK_LIBRARIES};OpenCL::OpenCL")
add_library(OPM::VexCL::OpenCL INTERFACE IMPORTED)
set_target_properties(OPM::VexCL::OpenCL PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "${VEXCL_COMPILE_DEFINITIONS}"
INTERFACE_LINK_LIBRARIES "${VEXCL_LINK_LIBRARIES}")
Prevent warnings form VexCL/amgcl using system include directories.
2021-06-30 09:41:35 -05:00
target_include_directories(OPM::VexCL::OpenCL SYSTEM INTERFACE "${VEXCL_INCLUDE_DIRS}")
Search for VexCL and create an imported target. Unfortunately, we cannot us the imported targets. They add some compile parameters using generator expressions based on the CXX_COMPILER_ID. While we are using the system CXX compiler for most of the stuff, some cuda code is compiled with nvcc which at least for some versions does not support -Wno-catch-value (which gets passed as normal compiler option).
2021-06-30 09:03:14 -05:00
endif()
endif()
Add rocalutionSolver
2022-10-18 06:59:00 -05:00
find_package(rocalution)
if(ROCALUTION_FOUND)
set(HAVE_ROCALUTION 1)
Combine multiple defines into one
2022-11-17 02:59:49 -06:00
set(COMPILE_BDA_BRIDGE 1)
Add rocalutionSolver
2022-10-18 06:59:00 -05:00
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")
Add inline fmtlib code in source tree
2020-09-28 04:01:13 -05:00
Enable usage of fmtlib on the system. If fmtlib is present on the system we used that one in the normal mode (not header only). Otherwise we fallback to the embedded one header only. Searching for the library is done on opm-common.
2021-03-11 13:03:00 -06:00
if(NOT fmt_FOUND)
add_definitions(-DFMT_HEADER_ONLY)
list(APPEND EXTRA_INCLUDES SYSTEM ${PROJECT_SOURCE_DIR}/external/fmtlib/include)
endif()
Add inline fmtlib code in source tree
2020-09-28 04:01:13 -05:00
include_directories(${EXTRA_INCLUDES})
fix cmake handling - use imported target for linking - use separate damaris cmake script - handle HAVE_DAMARIS config variable in the usual way fixing issues when user does not provide an outputDir via a command_line avoid adding damaris's command lines when we dont have damaris
2022-10-12 04:19:00 -05:00
include(UseDamaris)
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)
[OpenCL] Moves all OpenCL kernels to *.cl files. Kernel files are located in opm/simulators/linalg/bda/opencl/kernels. CMake will combine them for usage in ${PROJECT_BINARY_DIR}/clSources.cpp that becomes part of the library.
2021-12-10 05:17:19 -06:00
if(OPENCL_FOUND)
include(opencl-source-provider)
list(APPEND opm-simulators_SOURCES ${PROJECT_BINARY_DIR}/clSources.cpp)
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
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)
Changes needed to add Damaris functionality. The current state is that we output the pressure field and we use both HDF5 and parallel HDF5. Damaris initialization is added after InitMpi but before starting the simulation. Damaris will invoke a separate core for writing in parallel and leave the rest of cores for the simulator. The main changes are in main where start_damaris and then in eclwriterm where we use damaris to output the PRESSURE. To test Damaris one can use --enable-damaris-output=true and to use parallel HDF5 one can use --enable-async-damaris-output=true (false is the default choice)
2021-10-22 04:09:12 -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
changed: use getopts in test drivers the number of options were getting unmanagable as a flat list. also add help/usage to the scripts
2021-10-13 03:47:23 -05:00
-n 4
-b ${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
changed: use getopts in test drivers the number of options were getting unmanagable as a flat list. also add help/usage to the scripts
2021-10-13 03:47:23 -05:00
-n 4
-b ${PROJECT_BINARY_DIR}
gather deferredLogger implemented
2019-01-11 06:53:18 -06:00
)
Also test ParallelWellInfo with an MPI run if possible.
2020-12-09 08:37:03 -06:00
opm_add_test(test_parallelwellinfo_mpi
fixed: do not build test_parallelwellinfo.cpp twice mark the parallel test NO_COMPILE and specify the binary
2021-04-30 10:00:20 -05:00
EXE_NAME
test_parallelwellinfo
Also test ParallelWellInfo with an MPI run if possible.
2020-12-09 08:37:03 -06:00
CONDITION
MPI_FOUND AND Boost_UNIT_TEST_FRAMEWORK_FOUND
DRIVER_ARGS
changed: use getopts in test drivers the number of options were getting unmanagable as a flat list. also add help/usage to the scripts
2021-10-13 03:47:23 -05:00
-n 4
-b ${PROJECT_BINARY_DIR}
fixed: do not build test_parallelwellinfo.cpp twice mark the parallel test NO_COMPILE and specify the binary
2021-04-30 10:00:20 -05:00
NO_COMPILE
Also test ParallelWellInfo with an MPI run if possible.
2020-12-09 08:37:03 -06:00
)
added: utility to broadcast multiple variables in one operation
2021-11-09 04:48:06 -06:00
opm_add_test(test_broadcast
DEPENDS "opmsimulators"
LIBRARIES opmsimulators ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}
SOURCES
tests/test_broadcast.cpp
CONDITION
MPI_FOUND AND Boost_UNIT_TEST_FRAMEWORK_FOUND
DRIVER_ARGS
-n 4
-b ${PROJECT_BINARY_DIR}
)
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()
fix build without variants and/or poly grid
2021-08-17 01:52:16 -05:00
if (NOT BUILD_FLOW_VARIANTS)
set(FLOW_VARIANTS_DEFAULT_ENABLE_IF "FALSE")
else()
set(FLOW_VARIANTS_DEFAULT_ENABLE_IF "TRUE")
endif()
if (NOT BUILD_FLOW_POLY_GRID)
set(FLOW_POLY_ONLY_DEFAULT_ENABLE_IF "FALSE")
else()
set(FLOW_POLY_ONLY_DEFAULT_ENABLE_IF "TRUE")
endif()
changed: move moduleVersion to a separate object library this to minimize re-linking due to compile timestamp support
2020-06-08 03:06:39 -05:00
add_library(moduleVersion OBJECT opm/simulators/utils/moduleVersion.cpp)
changed: reuse objects if building python inline
2020-09-25 04:06:31 -05:00
set_property(TARGET moduleVersion PROPERTY POSITION_INDEPENDENT_CODE ON)
changed: move moduleVersion to a separate object library this to minimize re-linking due to compile timestamp support
2020-06-08 03:06:39 -05:00
fixed: fix parallel builds we need the update-version target to run to generate the necessary headers.
2020-06-09 08:08:30 -05:00
# Strictly we only depend on the update-version target,
# but this is not exposed in a super-build.
add_dependencies(moduleVersion opmsimulators)
remove ebos
2021-11-01 03:03:27 -05:00
set(FLOW_MODELS blackoil brine energy extbo foam gasoil gaswater
allow for gas-water + brine
2021-12-08 07:35:22 -06:00
oilwater oilwater_brine gaswater_brine oilwater_polymer
Add gasoil + energy simulator Useful when combining CO2STORE + THERMAL This PR also fixes an issue with missing phases in computation of output temperature
2021-12-06 03:26:54 -06:00
oilwater_polymer_injectivity micp polymer solvent
Ensure DIFFUSE is supported. This is only instantiated for two-phase gas/oil and for 3-phase blackoil. Runtime safeguards have been added to avoid the mistake of running with a simulator combination that silently ignores DIFFUSE.
2022-09-30 08:28:58 -05:00
gasoil_energy brine_saltprecipitation
gaswater_saltprec_vapwat brine_precsalt_vapwat
Support gas dissolution in water (Rsw) - adapt to interface change in waterPvt() - add gas + water + disgasw simulator Note - MSW is not supported - EQUIL initialization is not supported
2022-11-24 07:32:41 -06:00
blackoil_legacyassembly gasoildiffuse gaswater_dissolution
gaswater_dissolution_diffuse)
Ensure DIFFUSE is supported. This is only instantiated for two-phase gas/oil and for 3-phase blackoil. Runtime safeguards have been added to avoid the mistake of running with a simulator combination that silently ignores DIFFUSE.
2022-09-30 08:28:58 -05:00
set(FLOW_VARIANT_MODELS brine_energy onephase onephase_energy)
changed: simplify build system a little use lists for models to avoid repeating
2020-11-18 06:00:32 -06:00
changed: compile each flow simulator as a object library increases parallelism
2020-10-23 04:53:50 -05:00
set(FLOW_TGTS)
changed: build separate simulator binaries for flow this is very convenient during development. we can then remove the FLOW_BLACKOIL_ONLY option, as it is no longer needed - use the flow_blackoil binary instead. however we need to keep this support in Main.hpp due to the python bindings relying on it.
2021-11-01 02:33:17 -05:00
foreach(OBJ ${COMMON_MODELS} ${FLOW_MODELS} ${FLOW_VARIANT_MODELS})
changed: compile each flow simulator as a object library increases parallelism
2020-10-23 04:53:50 -05:00
add_library(flow_lib${OBJ} OBJECT flow/flow_ebos_${OBJ}.cpp)
list(APPEND FLOW_TGTS $<TARGET_OBJECTS:flow_lib${OBJ}>)
fixed: we have to "link" these to the fmt::fmt target if not, the required defines are not set when building with external libfmt
2021-04-09 04:31:16 -05:00
if(TARGET fmt::fmt)
target_link_libraries(flow_lib${OBJ} fmt::fmt)
endif()
changed: build separate simulator binaries for flow this is very convenient during development. we can then remove the FLOW_BLACKOIL_ONLY option, as it is no longer needed - use the flow_blackoil binary instead. however we need to keep this support in Main.hpp due to the python bindings relying on it.
2021-11-01 02:33:17 -05:00
opm_add_test(flow_${OBJ}
ONLY_COMPILE
SOURCES
flow/flow_${OBJ}.cpp
$<TARGET_OBJECTS:moduleVersion>
$<TARGET_OBJECTS:flow_lib${OBJ}>
EXE_NAME flow_${OBJ}
DEPENDS opmsimulators
LIBRARIES opmsimulators)
changed: compile each flow simulator as a object library increases parallelism
2020-10-23 04:53:50 -05:00
endforeach()
changed: reuse objects if building python inline
2020-09-25 04:06:31 -05:00
set_property(TARGET flow_libblackoil PROPERTY POSITION_INDEPENDENT_CODE ON)
changed: build separate simulator binaries for flow this is very convenient during development. we can then remove the FLOW_BLACKOIL_ONLY option, as it is no longer needed - use the flow_blackoil binary instead. however we need to keep this support in Main.hpp due to the python bindings relying on it.
2021-11-01 02:33:17 -05:00
foreach(OBJ ${FLOW_VARIANT_MODELS})
build flow_brine_energy as an object library improves parallel builds
2021-10-18 05:34:09 -05:00
set_property(TARGET flow_lib${OBJ} PROPERTY EXCLUDE_FROM_ALL ${FLOW_VARIANTS_DEFAULT_ENABLE_IF})
endforeach()
changed: build onephase simulators as object libraries allows for building in parallel with the main library
2021-08-16 05:40:41 -05:00
fix build without variants and/or poly grid
2021-08-17 01:52:16 -05:00
add_library(flow_libblackoil_poly OBJECT flow/flow_ebos_blackoil_poly.cpp)
if(TARGET fmt::fmt)
target_link_libraries(flow_libblackoil_poly fmt::fmt)
endif()
set_property(TARGET flow_libblackoil_poly PROPERTY EXCLUDE_FROM_ALL ${FLOW_POLY_ONLY_DEFAULT_ENABLE_IF})
changed: build polygrid simulator as a object library allows for building in parallel with the main library
2021-08-16 05:40:41 -05:00
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}
changed: move moduleVersion to a separate object library this to minimize re-linking due to compile timestamp support
2020-06-08 03:06:39 -05:00
DEPENDS opmsimulators
LIBRARIES opmsimulators
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
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
changed: compile each flow simulator as a object library increases parallelism
2020-10-23 04:53:50 -05:00
${FLOW_TGTS}
changed: reuse objects if building python inline
2020-09-25 04:06:31 -05:00
$<TARGET_OBJECTS:moduleVersion>
)
changed: move moduleVersion to a separate object library this to minimize re-linking due to compile timestamp support
2020-06-08 03:06:39 -05:00
Make a flow version that uses the polyhedreal grid Currently the simulator creats the polyhedreal grid from an eclGrid from opm-common TODO - make it possible to create the grid directly from DGF or MRST format - fix issue on norne.
2020-11-10 01:54:44 -06:00
opm_add_test(flow_poly
ONLY_COMPILE
ALWAYS_ENABLE
DEFAULT_ENABLE_IF ${FLOW_POLY_ONLY_DEFAULT_ENABLE_IF}
DEPENDS opmsimulators
LIBRARIES opmsimulators
SOURCES
flow/flow_blackoil_poly.cpp
changed: build polygrid simulator as a object library allows for building in parallel with the main library
2021-08-16 05:40:41 -05:00
$<TARGET_OBJECTS:flow_libblackoil_poly>
Make a flow version that uses the polyhedreal grid Currently the simulator creats the polyhedreal grid from an eclGrid from opm-common TODO - make it possible to create the grid directly from DGF or MRST format - fix issue on norne.
2020-11-10 01:54:44 -06:00
$<TARGET_OBJECTS:moduleVersion>)
target_compile_definitions(flow_poly PRIVATE USE_POLYHEDRALGRID)
Add a flow executable that only distributes cells in z-direction. Executable is named flow_distribute_z and uses the external loadbalancing information. It can be used to test the distributed standard wells on SPE9 with 4 or more processes.
2021-01-26 14:17:32 -06:00
opm_add_test(flow_distribute_z
ONLY_COMPILE
ALWAYS_ENABLE
DEFAULT_ENABLE_IF ${FLOW_DEFAULT_ENABLE_IF}
DEPENDS opmsimulators
LIBRARIES opmsimulators
SOURCES
flow/flow_distribute_z.cpp
${FLOW_TGTS}
$<TARGET_OBJECTS:moduleVersion>
)
rebasing
2021-12-01 07:00:21 -06:00
disable flow_alugrid in buildsystem if dune-alugrid was not found
2022-11-15 06:52:02 -06:00
if(dune-alugrid_FOUND)
if (NOT BUILD_FLOW_ALU_GRID)
set(FLOW_ALUGRID_ONLY_DEFAULT_ENABLE_IF "FALSE")
else()
set(FLOW_ALUGRID_ONLY_DEFAULT_ENABLE_IF "TRUE")
endif()
opm_add_test(flow_alugrid
ONLY_COMPILE
ALWAYS_ENABLE
DEFAULT_ENABLE_IF ${FLOW_ALUGRID_ONLY_DEFAULT_ENABLE_IF}
DEPENDS opmsimulators
LIBRARIES opmsimulators
SOURCES
flow/flow_blackoil_alugrid.cpp
$<TARGET_OBJECTS:moduleVersion>)
target_compile_definitions(flow_alugrid PRIVATE USE_ALUGRID)
endif()
Make a flow version that uses the polyhedreal grid Currently the simulator creats the polyhedreal grid from an eclGrid from opm-common TODO - make it possible to create the grid directly from DGF or MRST format - fix issue on norne.
2020-11-10 01:54:44 -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_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 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)
Added fpgaSolver
2020-12-22 05:57:01 -06:00
# must link libraries after target 'opmsimulators' has been defined
clean-up after rebase
2020-01-09 02:32:24 -06:00
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()
Added openclSolver Usage: --gpu-mode=[cusparse|opencl|none] on command line
2020-06-22 11:26:49 -05:00
if(OpenCL_FOUND)
Consistently use keyword version of target_link_libraries. Fixes: CMake Error at CMakeLists.txt:458 (target_link_libraries): The keyword signature for target_link_libraries has already been used with the target "opmsimulators". All uses of target_link_libraries with a target must be either all-keyword or all-plain. The uses of the keyword signature are here: * /var/lib/jenkins/workspace/opm-common-PR-builder/mpi/install/share/opm/cmake/Modules/OpmCompile.cmake:61 (target_link_libraries) -- Configuring incomplete, errors occurred!
2021-04-01 07:29:31 -05:00
target_link_libraries( opmsimulators PUBLIC ${OpenCL_LIBRARIES} )
Added openclSolver Usage: --gpu-mode=[cusparse|opencl|none] on command line
2020-06-22 11:26:49 -05:00
endif()
Added fpgaSolver
2020-12-22 05:57:01 -06:00
Add rocalutionSolver
2022-10-18 06:59:00 -05:00
if(ROCALUTION_FOUND)
Simplify CMake for rocalution
2022-11-02 10:47:30 -05:00
target_include_directories(opmsimulators PUBLIC ${rocalution_INCLUDE_DIR}/rocalution)
Add rocalutionSolver
2022-10-18 06:59:00 -05:00
endif()
Search for VexCL and create an imported target. Unfortunately, we cannot us the imported targets. They add some compile parameters using generator expressions based on the CXX_COMPILER_ID. While we are using the system CXX compiler for most of the stuff, some cuda code is compiled with nvcc which at least for some versions does not support -Wno-catch-value (which gets passed as normal compiler option).
2021-06-30 09:03:14 -05:00
if(VexCL_FOUND)
target_link_libraries( opmsimulators PUBLIC OPM::VexCL::OpenCL )
endif()
Remove FPGASolver and references
2022-11-17 02:27:00 -06:00
fix cmake handling - use imported target for linking - use separate damaris cmake script - handle HAVE_DAMARIS config variable in the usual way fixing issues when user does not provide an outputDir via a command_line avoid adding damaris's command lines when we dont have damaris
2022-10-12 04:19:00 -05:00
if(Damaris_FOUND)
target_link_libraries(opmsimulators PUBLIC damaris)
Changes needed to add Damaris functionality. The current state is that we output the pressure field and we use both HDF5 and parallel HDF5. Damaris initialization is added after InitMpi but before starting the simulation. Damaris will invoke a separate core for writing in parallel and leave the rest of cores for the simulator. The main changes are in main where start_damaris and then in eclwriterm where we use damaris to output the PRESSURE. To test Damaris one can use --enable-damaris-output=true and to use parallel HDF5 one can use --enable-async-damaris-output=true (false is the default choice)
2021-10-22 04:09:12 -05:00
endif()
Added man pages for flow. Generated using: declare -A short_desc short_desc['flow']='Eclipse compatible parallel reservoir simulator' short_desc['ebos']='Eclipse compatible parallel reservoir simulator for research' for key in "${!short_desc[@]}"; do help2man -h "-h" --version-string="2021.04" --no-discard-stderr -n "${short_desc[$key]}" -N $key >\ $key.1 done Gbp-Pq: Name 0002-Added-man-pages-for-flow-and-ebos.patch
2021-04-21 06:08:14 -05:00
install(DIRECTORY doc/man1 DESTINATION ${CMAKE_INSTALL_MANDIR}
FILES_MATCHING PATTERN "*.1")
Changes needed to add Damaris functionality. The current state is that we output the pressure field and we use both HDF5 and parallel HDF5. Damaris initialization is added after InitMpi but before starting the simulation. Damaris will invoke a separate core for writing in parallel and leave the rest of cores for the simulator. The main changes are in main where start_damaris and then in eclwriterm where we use damaris to output the PRESSURE. To test Damaris one can use --enable-damaris-output=true and to use parallel HDF5 one can use --enable-async-damaris-output=true (false is the default choice)
2021-10-22 04:09:12 -05:00
Reference in New Issue Copy Permalink