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 #
# #
###########################################################################
2013-05-15 03:40:00 -05:00
2017-09-15 04:17:40 -05:00
# Mandatory call to project
2019-12-03 07:10:21 -06:00
2024-05-08 07:09:26 -05:00
cmake_minimum_required ( VERSION 3.10 )
2013-05-15 03:40:00 -05:00
2024-03-07 08:24:24 -06:00
project ( opm-simulators C CXX )
2019-12-03 07:10:21 -06:00
2015-05-27 04:51:28 -05:00
option ( SIBLING_SEARCH "Search for other modules in sibling directories?" ON )
2015-10-19 08:21:08 -05:00
set ( USE_OPENMP_DEFAULT OFF ) # Use of OpenMP is considered experimental
2019-03-06 04:54:21 -06:00
option ( BUILD_FLOW "Build the production oriented flow simulator?" ON )
2019-10-11 01:46:17 -05:00
option ( BUILD_FLOW_VARIANTS "Build the variants for flow by default?" OFF )
2024-05-31 03:40:31 -05:00
option ( BUILD_FLOW_FLOAT_VARIANTS "Build the variants for flow using float?" OFF )
2020-11-10 01:54:44 -06:00
option ( BUILD_FLOW_POLY_GRID "Build flow blackoil with polyhedral grid" OFF )
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 )
2022-05-18 07:41:13 -05:00
option ( OPM_INSTALL_PYTHON "Install python bindings?" ON )
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 )
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 )
2021-12-01 07:00:21 -06:00
option ( BUILD_FLOW_ALU_GRID "Build flow blackoil with alu grid" OFF )
2021-10-22 04:09:12 -05:00
option ( USE_DAMARIS_LIB "Use the Damaris library for asynchronous I/O?" OFF )
2024-11-04 03:47:34 -06:00
option ( USE_GPU_BRIDGE "Enable the GPU bridge (GPU/AMGCL solvers)" ON )
2023-08-15 07:35:25 -05:00
option ( USE_TRACY_PROFILER "Enable tracy profiling" OFF )
2024-03-11 09:30:51 -05:00
option ( CONVERT_CUDA_TO_HIP "Convert CUDA code to HIP (to run on AMD cards)" OFF )
2024-10-08 13:35:42 -05:00
set ( OPM_COMPILE_COMPONENTS "2;3;4;5;6;7" CACHE STRING "The components to compile support for" )
2024-10-09 00:17:25 -05:00
# Ensure OPM_COMPILE_COMPONENTS is a list of at least one element
if ( OPM_COMPILE_COMPONENTS STREQUAL "" )
message ( FATAL_ERROR "OPM_COMPILE_COMPONENTS must contain at least one component." )
endif ( )
2024-10-08 13:35:42 -05:00
# Check that OPM_COMPILE_COMPONENTS is a subset of 2,3,4,5,6,7
set ( valid_components "2;3;4;5;6;7" )
foreach ( component IN LISTS OPM_COMPILE_COMPONENTS )
list ( FIND valid_components ${ component } index )
if ( index EQUAL -1 )
message ( FATAL_ERROR "Invalid component ${component} in OPM_COMPILE_COMPONENTS. Valid components are: ${valid_components}" )
endif ( )
endforeach ( )
# Check for duplicates in OPM_COMPILE_COMPONENTS
list ( REMOVE_DUPLICATES OPM_COMPILE_COMPONENTS )
# Make a string we can use in the code
# this will be used in a template argument pack.
string ( REPLACE ";" "," OPM_COMPILE_COMPONENTS_TEMPLATE_LIST "${OPM_COMPILE_COMPONENTS}" )
2024-03-11 09:30:51 -05:00
2024-05-08 07:09:26 -05:00
# HIP requires cmake version 3.21
if ( CONVERT_CUDA_TO_HIP AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.21" )
2024-03-11 09:30:51 -05:00
enable_language ( HIP )
message ( "CUDA code will be hipified" )
set ( HAVE_CUDA 1 ) # we still need this defined so that the preprocessor does not remove the code
set ( CUDA_FOUND ON )
set ( USE_HIP 1 )
find_package ( hip REQUIRED )
find_package ( hipsparse REQUIRED )
find_package ( hipblas REQUIRED )
link_libraries ( roc::hipblas roc::hipsparse )
2024-05-08 07:28:44 -05:00
elseif ( CONVERT_CUDA_TO_HIP )
message ( "To generate HIP code for AMD GPUs run CMake with version >= 3.21" )
2024-03-11 09:30:51 -05:00
endif ( )
2020-01-13 08:46:50 -06:00
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 } )
2022-07-27 11:26:22 -05:00
set ( Python3_VERSION "${PYTHON_VERSION_STRING}" )
2022-06-07 01:29:33 -05:00
set ( Python3_VERSION_MINOR ${ PYTHON_VERSION_MINOR } )
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 ( )
2023-05-02 02:18:57 -05:00
if ( ${ CMAKE_VERSION } VERSION_LESS "3.18.0" )
find_package ( Python3 REQUIRED COMPONENTS Interpreter Development )
else ( )
find_package ( Python3 REQUIRED COMPONENTS Interpreter Development.Module )
endif ( )
2022-05-18 07:41:13 -05:00
endif ( )
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 ( )
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 ( )
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 } )
2017-09-15 04:34:22 -05:00
else ( )
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
A N D I S _ D I R E C T O R Y $ { _ p a r e n t _ f u l l _ d i r } / $ { _ o p m _ c o m m o n _ l e a f } )
# 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
2018-02-05 04:38:07 -06:00
set ( opm-common_DIR "${_parent_full_dir}/opm-common" )
2017-09-15 04:34:22 -05:00
endif ( )
2017-09-25 05:24:15 -05:00
endif ( )
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"
" o p m - c o m m o n _ D I R i s n o t a d i r e c t o r y " )
2017-09-25 05:24:15 -05:00
endif ( )
2015-03-18 08:26:29 -05:00
2017-09-25 05:24:15 -05:00
find_package ( opm-common REQUIRED )
2015-03-18 08:26:29 -05:00
2023-03-08 05:38:22 -06:00
include ( OpmInit )
OpmSetPolicies ( )
2023-02-09 16:30:02 -06:00
if ( USE_MPI )
set ( HDF5_PREFER_PARALLEL TRUE )
endif ( )
2024-11-04 03:47:34 -06:00
if ( USE_GPU_BRIDGE )
set ( COMPILE_GPU_BRIDGE 1 )
2023-08-09 08:39:32 -05:00
endif ( )
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 )
2013-05-15 03:40:00 -05:00
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 )
2013-05-15 03:40:00 -05:00
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 )
2015-10-21 10:35:44 -05:00
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
2015-05-15 08:43:03 -05:00
include ( "${project}-prereqs" )
2013-05-15 03:40:00 -05:00
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
2020-04-29 06:28:23 -05:00
# work for CMake >= 3.8. We found no way to make FindCUDA.cmake error
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
C M A K E _ V E R S I O N V E R S I O N _ G R E A T E R 3 . 7 . 9 )
2020-04-27 15:01:46 -05:00
if ( CMAKE_BUILD_TYPE )
set ( _flags_suffix "_${CMAKE_BUILD_TYPE}" )
endif ( )
2020-04-29 06:27:04 -05:00
if ( NOT DEFINED ENV{CUDAHOSTCXX} AND NOT DEFINED CMAKE_CUDA_HOST_COMPILER AND
2020-04-27 15:01:46 -05:00
( N O T C M A K E _ C U D A _ F L A G S $ { _ f l a g s _ s u f f i x } O R N O T C M A K E _ C U D A _ F L A G S $ { _ f l a g s _ s u f f i x } M A T C H E S " . * - c c b i n . * " ) )
2020-04-29 06:27:04 -05:00
message ( STATUS "Setting CUDA host compiler CMAKE_CUDA_HOST_COMPILER to ${CMAKE_CXX_COMPILER} to "
2020-04-27 07:54:08 -05:00
" p r e v e n t i n c o m p a t i b i l i t i e s . N o t e t h a t t h i s m i g h t r e p o r t t h a t t h e r e "
" i s n o t C U D A c o m p i l e r i f y o u r s y s t e m ' s C U D A c o m p i l e r d o e s n o t s u p p o r t "
" $ { C M A K E _ C X X _ C O M P I L E R } . " )
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
2020-04-27 14:52:41 -05:00
# in "${NVCC} -ccbin=${CMAKE_CXX_COMPILER} -ccbin ${CMAKE_CXX_COMPILER}"
2020-04-29 06:28:23 -05:00
# which causes nvcc to abort
2020-04-29 06:27:04 -05:00
set ( CMAKE_CUDA_HOST_COMPILER ${ CMAKE_CXX_COMPILER } )
2020-04-29 06:58:48 -05:00
set ( ENV{CUDAHOSTCXX} ${ CMAKE_CUDA_HOST_COMPILER } ) # The only thing honored by check_language(CUDA)!
2020-04-02 13:30:20 -05:00
endif ( )
include ( CheckLanguage )
check_language ( CUDA )
if ( CMAKE_CUDA_COMPILER )
2020-04-29 06:28:23 -05:00
# OPTIONAL is ignored. Hence the magic above to check whether enabling CUDA works
2020-04-02 13:30:20 -05:00
enable_language ( CUDA OPTIONAL )
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 )
2024-03-11 09:30:51 -05:00
set ( CUDA_FOUND ON )
2020-04-02 13:30:20 -05:00
endif ( )
2020-04-15 07:21:36 -05:00
if ( CUDA_FOUND AND CUDA_VERSION VERSION_LESS "9.0" )
2020-04-02 13:30:20 -05:00
set ( CUDA_FOUND OFF )
message ( WARNING "Deactivating CUDA as we require version 9.0 or newer."
" F o u n d o n l y C U D A v e r s i o n $ { C U D A _ V E R S I O N } . " )
endif ( )
endif ( )
2024-03-11 09:30:51 -05:00
find_package ( CUDAToolkit )
2020-04-02 13:30:20 -05:00
if ( CUDA_FOUND )
set ( HAVE_CUDA 1 )
2024-03-11 09:30:51 -05:00
if ( NOT USE_HIP ) # no need to include CUDA files if we use rocm stack
include_directories ( ${ CUDA_INCLUDE_DIRS } )
include_directories ( ${ CUDAToolkit_INCLUDE_DIRS } )
endif ( )
2020-04-02 13:30:20 -05:00
endif ( )
2020-06-22 11:26:49 -05:00
find_package ( OpenCL )
if ( OpenCL_FOUND )
2021-10-28 09:18:07 -05:00
# the current OpenCL implementation relies on cl2.hpp, not cl.hpp
2020-06-25 11:44:49 -05:00
# make sure it is available, otherwise disable OpenCL
2021-10-28 09:18:07 -05:00
find_file ( CL2_HPP CL/cl2.hpp HINTS ${ OpenCL_INCLUDE_DIRS } )
if ( CL2_HPP )
2020-06-25 11:44:49 -05:00
set ( HAVE_OPENCL 1 )
include_directories ( ${ OpenCL_INCLUDE_DIRS } )
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 ( )
2020-06-25 11:44:49 -05:00
else ( )
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" )
2020-06-25 11:44:49 -05:00
set ( OpenCL_FOUND OFF )
2020-07-28 04:49:01 -05:00
set ( OPENCL_FOUND OFF )
2020-06-25 11:44:49 -05:00
endif ( )
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 ( )
2020-06-22 11:26:49 -05:00
endif ( )
2021-06-18 04:46:00 -05:00
find_package ( amgcl )
if ( amgcl_FOUND )
2021-06-02 09:19:00 -05:00
set ( HAVE_AMGCL 1 )
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.
2021-06-21 04:13:34 -05:00
# Hence we set AMGCL_INCLUDE_DIRS.
2021-06-18 12:40:46 -05:00
get_property ( AMGCL_INCLUDE_DIRS TARGET amgcl::amgcl PROPERTY INTERFACE_INCLUDE_DIRECTORIES )
2021-06-30 09:41:35 -05:00
include_directories ( SYSTEM ${ AMGCL_INCLUDE_DIRS } )
2021-06-02 09:19:00 -05:00
endif ( )
2021-06-30 09:03:14 -05:00
if ( OpenCL_FOUND )
find_package ( VexCL )
if ( VexCL_FOUND )
set ( HAVE_VEXCL 1 )
# 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
I N T E R F A C E _ C O M P I L E _ D E F I N I T I O N S " $ { V E X C L _ C O M P I L E _ D E F I N I T I O N S } "
I N T E R F A C E _ L I N K _ L I B R A R I E S " $ { V E X C L _ L I N K _ L I B R A R I E S } " )
2021-06-30 09:41:35 -05:00
target_include_directories ( OPM::VexCL::OpenCL SYSTEM INTERFACE "${VEXCL_INCLUDE_DIRS}" )
2021-06-30 09:03:14 -05:00
endif ( )
endif ( )
2022-10-18 06:59:00 -05:00
2013-08-02 07:07:33 -05:00
macro ( config_hook )
2019-06-13 07:59:31 -05:00
opm_need_version_of ( "dune-common" )
opm_need_version_of ( "dune-istl" )
2019-10-22 05:49:06 -05:00
if ( dune-fem_FOUND )
opm_need_version_of ( "dune-fem" )
endif ( )
2020-09-28 04:01:13 -05:00
2021-03-11 13:03:00 -06:00
if ( NOT fmt_FOUND )
2023-11-21 08:10:26 -06:00
include ( DownloadFmt )
2021-03-11 13:03:00 -06:00
endif ( )
2023-08-15 07:35:25 -05:00
if ( USE_TRACY_PROFILER AND Tracy_FOUND )
set ( USE_TRACY 1 )
list ( APPEND opm-simulators_LIBRARIES Tracy::TracyClient )
else ( )
set ( USE_TRACY )
endif ( )
2020-09-28 04:01:13 -05:00
include_directories ( ${ EXTRA_INCLUDES } )
2022-10-12 04:19:00 -05:00
include ( UseDamaris )
2024-05-31 03:40:31 -05:00
if ( BUILD_FLOW_FLOAT_VARIANTS )
set ( FLOW_INSTANTIATE_FLOAT 1 )
endif ( )
2024-08-09 03:38:35 -05:00
# The parameter system can leverage std::from_chars() for
# floating-point types if available. Detect support for this
# feature.
try_compile (
h a v e _ f l o a t _ f r o m _ c h a r s
$ { C M A K E _ B I N A R Y _ D I R }
$ { P R O J E C T _ S O U R C E _ D I R } / c m a k e / t e s t / t e s t F l o a t F r o m C h a r s . c p p
C X X _ S T A N D A R D 1 7
)
2024-11-22 03:34:25 -06:00
unset ( HAVE_FLOATING_POINT_FROM_CHARS )
2024-08-09 03:38:35 -05:00
if ( have_float_from_chars )
set ( HAVE_FLOATING_POINT_FROM_CHARS 1 )
endif ( )
2023-04-06 03:04:44 -05:00
endmacro ( config_hook )
macro ( prereqs_hook )
endmacro ( prereqs_hook )
macro ( sources_hook )
if ( OPENCL_FOUND )
include ( opencl-source-provider )
list ( APPEND opm-simulators_SOURCES ${ PROJECT_BINARY_DIR } /clSources.cpp )
endif ( )
2024-09-02 07:19:33 -05:00
if ( QuadMath_FOUND )
get_target_property ( qm_defs QuadMath::QuadMath INTERFACE_COMPILE_DEFINITIONS )
list ( APPEND qm_defs HAVE_QUAD=1 )
get_target_property ( qm_options QuadMath::QuadMath INTERFACE_COMPILE_OPTIONS )
2024-09-16 01:43:09 -05:00
set_source_files_properties ( opm/models/nonlinear/newtonmethodparams.cpp
o p m / m o d e l s / u t i l s / p a r a m e t e r s y s t e m . c p p
2024-09-05 06:06:09 -05:00
o p m / m o d e l s / u t i l s / s i m u l a t o r u t i l s . c p p
2024-09-02 07:19:33 -05:00
P R O P E R T I E S C O M P I L E _ D E F I N I T I O N S " $ { q m _ d e f s } "
C O M P I L E _ O P T I O N S " $ { q m _ o p t i o n s } " )
endif ( )
2023-04-06 03:04:44 -05:00
endmacro ( sources_hook )
macro ( fortran_hook )
endmacro ( fortran_hook )
2023-03-16 07:39:07 -05:00
2023-04-06 03:04:44 -05:00
macro ( files_hook )
2023-03-16 07:39:07 -05:00
if ( hip_FOUND )
get_filename_component ( CXX_COMPILER ${ CMAKE_CXX_COMPILER } NAME )
if ( hip_VERSION VERSION_LESS "5.3" )
2023-03-30 08:28:26 -05:00
if ( ROCALUTION_FOUND AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU" )
message ( WARNING " Cannot use hipcc/clang for rocalution with rocm < 5.3\n Disabling rocalutionSolver" )
unset ( ROCALUTION_FOUND )
unset ( HAVE_ROCALUTION )
2023-03-16 07:39:07 -05:00
endif ( )
2023-10-02 07:14:43 -05:00
endif ( )
if ( rocsparse_FOUND AND rocblas_FOUND )
set ( HAVE_ROCSPARSE 1 )
2023-03-16 07:39:07 -05:00
else ( )
2023-10-02 07:14:43 -05:00
unset ( HAVE_ROCSPARSE )
2023-03-30 08:28:26 -05:00
endif ( )
if ( ROCALUTION_FOUND )
set ( HAVE_ROCALUTION 1 )
2023-03-16 07:39:07 -05:00
endif ( )
endif ( )
2023-02-22 03:43:25 -06:00
if ( MPI_FOUND AND HDF5_FOUND AND NOT HDF5_IS_PARALLEL )
message ( WARNING "When building parallel OPM flow we need a "
" p a r a l l e l v e r s i o n o f h d f 5 , b u t f o u n d o n l y a s e r i a l o n e . "
" P l e a s e i n s t a l l a p a r a l l e l h d f 5 l i b r a r y f o r M P I "
" ( e . g w i t h a p t - g e t i n s t a l l l i b h d f 5 - m p i - d e v ) a n d d o a c l e a n "
" rebuild ( build after \"make clean\ "). Continuing with "
" o n l y n o r m a l r e s t a r t w i t h o u t h d f 5 f i l e s u p p o r t . " )
set ( HDF5_FOUND OFF )
unset ( HAVE_HDF5 )
endif ( )
2024-11-04 03:47:34 -06:00
if ( HAVE_ROCSPARSE AND HAVE_CUDA AND USE_GPU_BRIDGE ) # unsure if this is the correct way to change this
2023-10-11 06:29:40 -05:00
message ( WARNING "WARNING! Using CUDA and ROCm at the same time is not allowed. Please choose only one of them by setting CMAKE_DISABLE_FIND_PACKAGE_<rocsparse|CUDA>=<ON|OFF>. Disabling CUDA...\n" )
2023-10-08 01:57:37 -05:00
set ( CUDA_FOUND OFF )
unset ( HAVE_CUDA )
endif ( )
2023-02-22 03:43:25 -06: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 needs to be here to make reset HDF5_FOUND available in
# (CMakeLists_files.cmake and because we need the created lists during
# then inclusion of OpmLibMain
include ( CMakeLists_files.cmake )
2014-06-16 07:40:52 -05:00
endmacro ( files_hook )
2013-08-02 07:07:33 -05:00
macro ( tests_hook )
endmacro ( tests_hook )
2023-08-01 06:41:51 -05:00
2013-08-02 07:07:33 -05:00
# all setup common to the OPM library modules is done here
include ( OpmLibMain )
2013-05-15 03:40:00 -05:00
2023-07-03 02:05:45 -05:00
opm_add_test ( test_tuning_xxxMBE
S O U R C E S
t e s t s / t e s t _ t u n i n g _ X X X M B E . c p p
L I B R A R I E S
$ { B o o s t _ U N I T _ T E S T _ F R A M E W O R K _ L I B R A R Y }
2023-08-25 06:59:11 -05:00
O N L Y _ C O M P I L E )
opm_add_test ( test_tuning_tsinit_nextstep
S O U R C E S
t e s t s / t e s t _ t u n i n g _ T S I N I T _ N E X T S T E P . c p p
L I B R A R I E S
$ { B o o s t _ U N I T _ T E S T _ F R A M E W O R K _ L I B R A R Y } o p m c o m m o n
2023-07-03 02:05:45 -05:00
O N L Y _ C O M P I L E )
2024-08-09 03:38:35 -05:00
# this test is identical to the simulation of the lens problem that
# uses the element centered finite volume discretization in
# conjunction with automatic differentiation
# (lens_immiscible_ecfv_ad). The only difference is that it uses
# multiple compile units in order to ensure that eWoms code can be
# used within libraries that use the same type tag within multiple
# compile units.
opm_add_test ( lens_immiscible_ecfv_ad_mcu
S O U R C E S
e x a m p l e s / l e n s _ i m m i s c i b l e _ e c f v _ a d _ c u 1 . c p p
e x a m p l e s / l e n s _ i m m i s c i b l e _ e c f v _ a d _ c u 2 . c p p
e x a m p l e s / l e n s _ i m m i s c i b l e _ e c f v _ a d _ m a i n . c p p
L I B R A R I E S
o p m s i m u l a t o r s o p m c o m m o n
O N L Y _ C O M P I L E )
if ( QuadMath_FOUND )
foreach ( tapp co2injection_flash_ni_ecfv
c o 2 i n j e c t i o n _ f l a s h _ n i _ v c f v
c o 2 i n j e c t i o n _ f l a s h _ e c f v
c o 2 i n j e c t i o n _ f l a s h _ v c f v )
opm_add_test ( ${ tapp } _quad
2024-09-03 02:52:31 -05:00
L I B R A R I E S o p m s i m u l a t o r s o p m c o m m o n
2024-08-09 03:38:35 -05:00
E X E _ N A M E $ { t a p p } _ q u a d
S O U R C E S
e x a m p l e s / $ { t a p p } . c p p
O N L Y _ C O M P I L E )
target_link_libraries ( ${ tapp } _quad QuadMath::QuadMath )
target_compile_definitions ( ${ tapp } _quad PRIVATE HAVE_QUAD=1 )
endforeach ( )
endif ( )
target_sources ( test_outputdir PRIVATE $< TARGET_OBJECTS:moduleVersion > )
target_sources ( test_equil PRIVATE $< TARGET_OBJECTS:moduleVersion > )
target_sources ( test_RestartSerialization PRIVATE $< TARGET_OBJECTS:moduleVersion > )
target_sources ( test_glift1 PRIVATE $< TARGET_OBJECTS:moduleVersion > )
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /modelTests.cmake )
2018-03-12 09:37:21 -05:00
if ( HAVE_OPM_TESTS )
2024-08-08 05:20:33 -05:00
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /compareECLFiles.cmake )
2024-09-06 06:12:15 -05:00
if ( OPM_ENABLE_PYTHON )
if ( ${ CMAKE_BINARY_DIR } STREQUAL ${ PROJECT_BINARY_DIR } )
set ( sim_dir ${ CMAKE_BINARY_DIR } )
else ( )
set ( sim_dir ${ CMAKE_BINARY_DIR } /opm-simulators )
endif ( )
add_custom_target ( failure_report
U S E S _ T E R M I N A L
C O M M A N D $ { C M A K E _ C O M M A N D } - E e n v " P Y T H O N P A T H = $ { o p m - c o m m o n _ D I R } / p y t h o n "
$ { P R O J E C T _ S O U R C E _ D I R } / t e s t s / m a k e _ f a i l u r e _ r e p o r t . s h
$ { O P M _ T E S T S _ R O O T } $ { C M A K E _ B I N A R Y _ D I R } $ { s i m _ d i r } )
endif ( )
2024-08-08 05:20:33 -05:00
endif ( )
if ( MPI_FOUND )
include ( ${ CMAKE_CURRENT_SOURCE_DIR } /parallelUnitTests.cmake )
2017-03-03 08:08:12 -06:00
endif ( )
2018-09-19 04:45:40 -05:00
2019-03-06 04:54:21 -06:00
include ( OpmBashCompletion )
2019-01-11 06:53:18 -06:00
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 ( )
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 ( )
2020-06-08 03:06:39 -05:00
add_library ( moduleVersion OBJECT opm/simulators/utils/moduleVersion.cpp )
2020-09-25 04:06:31 -05:00
set_property ( TARGET moduleVersion PROPERTY POSITION_INDEPENDENT_CODE ON )
2020-06-08 03:06:39 -05:00
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 )
2021-11-01 03:03:27 -05:00
set ( FLOW_MODELS blackoil brine energy extbo foam gasoil gaswater
2021-12-08 07:35:22 -06:00
o i l w a t e r o i l w a t e r _ b r i n e g a s w a t e r _ b r i n e o i l w a t e r _ p o l y m e r
2023-05-02 08:41:07 -05:00
o i l w a t e r _ p o l y m e r _ i n j e c t i v i t y m i c p p o l y m e r s o l v e n t s o l v e n t _ f o a m
2022-09-30 08:28:58 -05:00
g a s o i l _ e n e r g y b r i n e _ s a l t p r e c i p i t a t i o n
2023-05-04 03:25:58 -05:00
g a s w a t e r _ s a l t p r e c _ v a p w a t g a s w a t e r _ s a l t p r e c _ e n e r g y b r i n e _ p r e c s a l t _ v a p w a t
2022-11-24 07:32:41 -06:00
b l a c k o i l _ l e g a c y a s s e m b l y g a s o i l d i f f u s e g a s w a t e r _ d i s s o l u t i o n
2023-03-29 01:21:54 -05:00
g a s w a t e r _ d i s s o l u t i o n _ d i f f u s e g a s w a t e r _ e n e r g y g a s w a t e r _ s o l v e n t )
2022-09-30 08:28:58 -05:00
set ( FLOW_VARIANT_MODELS brine_energy onephase onephase_energy )
2020-11-18 06:00:32 -06:00
2020-10-23 04:53:50 -05:00
set ( FLOW_TGTS )
2021-11-01 02:33:17 -05:00
foreach ( OBJ ${ COMMON_MODELS } ${ FLOW_MODELS } ${ FLOW_VARIANT_MODELS } )
2024-02-01 06:39:45 -06:00
add_library ( flow_lib ${ OBJ } OBJECT flow/flow_ ${ OBJ } .cpp )
2020-10-23 04:53:50 -05:00
list ( APPEND FLOW_TGTS $< TARGET_OBJECTS:flow_lib${OBJ} > )
2021-04-09 04:31:16 -05:00
if ( TARGET fmt::fmt )
target_link_libraries ( flow_lib ${ OBJ } fmt::fmt )
endif ( )
2023-11-22 05:27:31 -06:00
if ( TARGET opmcommon )
2023-06-30 07:58:31 -05:00
add_dependencies ( flow_lib ${ OBJ } opmcommon )
endif ( )
2021-11-01 02:33:17 -05:00
opm_add_test ( flow_ ${ OBJ }
O N L Y _ C O M P I L E
S O U R C E S
2024-02-01 04:05:17 -06:00
f l o w / f l o w _ $ { O B J } _ m a i n . c p p
2021-11-01 02:33:17 -05:00
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n >
$ < T A R G E T _ O B J E C T S : f l o w _ l i b $ { O B J } >
E X E _ N A M E f l o w _ $ { O B J }
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s )
2020-10-23 04:53:50 -05:00
endforeach ( )
2020-09-25 04:06:31 -05:00
set_property ( TARGET flow_libblackoil PROPERTY POSITION_INDEPENDENT_CODE ON )
2021-11-01 02:33:17 -05:00
foreach ( OBJ ${ FLOW_VARIANT_MODELS } )
2021-10-18 05:34:09 -05:00
set_property ( TARGET flow_lib ${ OBJ } PROPERTY EXCLUDE_FROM_ALL ${ FLOW_VARIANTS_DEFAULT_ENABLE_IF } )
endforeach ( )
2021-08-16 05:40:41 -05:00
2018-09-20 03:58:27 -05:00
opm_add_test ( flow
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
2019-03-07 05:45:15 -06:00
D E F A U L T _ E N A B L E _ I F $ { F L O W _ D E F A U L T _ E N A B L E _ I F }
2020-06-08 03:06:39 -05:00
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
2018-09-20 03:58:27 -05:00
S O U R C E S
2019-03-07 05:45:15 -06:00
f l o w / f l o w . c p p
2020-10-23 04:53:50 -05:00
$ { F L O W _ T G T S }
2020-09-25 04:06:31 -05:00
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n >
)
2020-06-08 03:06:39 -05:00
2023-08-01 06:41:51 -05:00
opm_add_test ( flow_blackoil_polyhedralgrid
2020-11-10 01:54:44 -06:00
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
D E F A U L T _ E N A B L E _ I F $ { F L O W _ P O L Y _ O N L Y _ D E F A U L T _ E N A B L E _ I F }
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
S O U R C E S
2023-08-01 06:41:51 -05:00
f l o w / f l o w _ b l a c k o i l _ p o l y h e d r a l g r i d . c p p
2020-11-10 01:54:44 -06:00
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n > )
2021-01-26 14:17:32 -06:00
opm_add_test ( flow_distribute_z
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
D E F A U L T _ E N A B L E _ I F $ { F L O W _ D E F A U L T _ E N A B L E _ I F }
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
S O U R C E S
f l o w / f l o w _ d i s t r i b u t e _ z . c p p
$ { F L O W _ T G T S }
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n >
)
2021-12-01 07:00:21 -06:00
2024-04-19 03:28:41 -05:00
opm_add_test ( flowexp_blackoil
2024-04-05 09:35:52 -05:00
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
S O U R C E S
2024-04-19 03:28:41 -05:00
f l o w e x p e r i m e n t a l / f l o w e x p _ b l a c k o i l . c p p
2024-04-05 09:35:52 -05:00
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n >
)
2024-10-08 13:35:42 -05:00
# We now specify the files we actually want to compile
set ( FLOWEXP_COMPONENTS_SOURCES )
foreach ( component IN LISTS OPM_COMPILE_COMPONENTS )
list ( APPEND FLOWEXP_COMPONENTS_SOURCES flowexperimental/comp/flowexp_comp ${ component } .cpp )
endforeach ( )
2024-09-11 07:35:05 -05:00
opm_add_test ( flowexp_comp
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
S O U R C E S
f l o w e x p e r i m e n t a l / c o m p / f l o w e x p _ c o m p . c p p
2024-10-08 13:35:42 -05:00
$ { F L O W E X P _ C O M P O N E N T S _ S O U R C E S }
2024-09-11 07:35:05 -05:00
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n >
)
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 ( )
2023-08-01 06:41:51 -05:00
opm_add_test ( flow_blackoil_alugrid
2022-11-15 06:52:02 -06:00
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
D E F A U L T _ E N A B L E _ I F $ { F L O W _ A L U G R I D _ O N L Y _ D E F A U L T _ E N A B L E _ I F }
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
S O U R C E S
f l o w / f l o w _ b l a c k o i l _ a l u g r i d . c p p
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n > )
endif ( )
2020-11-10 01:54:44 -06:00
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
C O M M A N D f l o w - - v e r s i o n )
set_tests_properties ( flow__version PROPERTIES
P A S S _ R E G U L A R _ E X P R E S S I O N " $ { $ { p r o j e c t } _ L A B E L } " )
2019-03-06 04:54:21 -06:00
endif ( )
2018-12-09 14:15:59 -06:00
2024-02-19 01:19:08 -06:00
if ( BUILD_FLOW_FLOAT_VARIANTS )
opm_add_test ( flow_blackoil_float
O N L Y _ C O M P I L E
A L W A Y S _ E N A B L E
D E F A U L T _ E N A B L E _ I F $ { F L O W _ D E F A U L T _ E N A B L E _ I F }
D E P E N D S o p m s i m u l a t o r s
L I B R A R I E S o p m s i m u l a t o r s
S O U R C E S
f l o w / f l o w _ b l a c k o i l _ f l o a t _ m a i n . c p p
$ < T A R G E T _ O B J E C T S : m o d u l e V e r s i o n > )
endif ( )
2019-10-31 10:41:13 -05:00
if ( OPM_ENABLE_PYTHON )
add_subdirectory ( python )
endif ( )
2020-01-09 02:32:24 -06:00
2020-04-03 03:15:49 -05:00
add_custom_target ( extra_test ${ CMAKE_CTEST_COMMAND } -C ExtraTests )
2020-12-22 05:57:01 -06:00
# must link libraries after target 'opmsimulators' has been defined
2020-01-09 02:32:24 -06:00
if ( CUDA_FOUND )
2024-03-11 09:30:51 -05:00
if ( NOT USE_HIP )
target_link_libraries ( opmsimulators PUBLIC ${ CUDA_cusparse_LIBRARY } )
target_link_libraries ( opmsimulators PUBLIC ${ CUDA_cublas_LIBRARY } )
2024-08-23 06:02:09 -05:00
foreach ( tgt test_gpu_safe_call test_cuda_check_last_error test_GpuVector )
2024-06-03 01:50:46 -05:00
target_link_libraries ( ${ tgt } CUDA::cudart )
endforeach ( )
2024-03-11 09:30:51 -05:00
endif ( )
2024-11-04 03:47:34 -06:00
if ( USE_GPU_BRIDGE )
2023-08-09 08:39:32 -05:00
set_tests_properties ( cusparseSolver PROPERTIES LABELS gpu_cuda )
endif ( )
2023-05-09 08:49:00 -05:00
# CUISTL
2024-03-11 09:30:51 -05:00
set ( gpu_label "gpu_cuda" )
if ( USE_HIP )
set ( gpu_label "gpu_hip" )
endif ( )
2023-05-09 09:00:57 -05:00
set_tests_properties ( cusparse_safe_call
c u b l a s _ s a f e _ c a l l
2024-08-23 04:12:13 -05:00
g p u _ s a f e _ c a l l
2023-05-09 09:00:57 -05:00
c u d a _ c h e c k _ l a s t _ e r r o r
c u b l a s _ h a n d l e
2024-08-22 07:40:23 -05:00
G p u J a c
2024-08-22 07:28:33 -05:00
G p u D I L U
2023-05-09 09:00:57 -05:00
c u s p a r s e _ h a n d l e
2023-10-16 04:31:00 -05:00
c u S p a r s e _ m a t r i x _ o p e r a t i o n s
c u V e c t o r _ o p e r a t i o n s
2024-08-22 08:20:20 -05:00
G p u V e c t o r
2024-08-22 08:14:33 -05:00
G p u S p a r s e M a t r i x
2024-08-22 08:07:53 -05:00
G p u S e q I L U 0
2024-08-22 07:46:38 -05:00
G p u O w n e r O v e r l a p C o p y
2023-05-31 07:51:00 -05:00
s o l v e r _ a d a p t e r
2024-08-22 07:12:30 -05:00
G p u B u f f e r
2024-08-22 08:27:23 -05:00
G p u V i e w
2024-09-11 04:51:51 -05:00
g p u _ a d
g p u _ l i n e a r _ t w o _ p h a s e _ m a t e r i a l
2024-09-23 07:55:07 -05:00
g p u P v t
2024-03-11 09:30:51 -05:00
P R O P E R T I E S L A B E L S $ { g p u _ l a b e l } )
2020-01-09 02:32:24 -06:00
endif ( )
2024-11-04 03:47:34 -06:00
if ( USE_GPU_BRIDGE )
2023-08-09 08:39:32 -05:00
if ( OpenCL_FOUND )
target_link_libraries ( opmsimulators PUBLIC ${ OpenCL_LIBRARIES } )
set_tests_properties ( openclSolver solvetransposed3x3 csrToCscOffsetMap
P R O P E R T I E S L A B E L S g p u _ o p e n c l )
endif ( )
2020-12-22 05:57:01 -06:00
2023-08-09 08:39:32 -05:00
if ( ROCALUTION_FOUND )
target_include_directories ( opmsimulators PUBLIC ${ rocalution_INCLUDE_DIR } /rocalution )
set_tests_properties ( rocalutionSolver PROPERTIES LABELS gpu_rocm )
endif ( )
2022-10-18 06:59:00 -05:00
2023-08-09 08:39:32 -05:00
if ( rocsparse_FOUND AND rocblas_FOUND )
target_link_libraries ( opmsimulators PUBLIC roc::rocsparse )
target_link_libraries ( opmsimulators PUBLIC roc::rocblas )
set_tests_properties ( rocsparseSolver PROPERTIES LABELS gpu_rocm )
endif ( )
2023-01-18 03:11:42 -06:00
2023-08-09 08:39:32 -05:00
if ( VexCL_FOUND )
target_link_libraries ( opmsimulators PUBLIC OPM::VexCL::OpenCL )
endif ( )
2021-06-30 09:03:14 -05:00
endif ( )
2022-11-17 02:27:00 -06:00
2024-05-28 08:15:37 -05:00
if ( USE_DAMARIS_LIB AND Damaris_FOUND )
2022-10-12 04:19:00 -05:00
target_link_libraries ( opmsimulators PUBLIC damaris )
2021-10-22 04:09:12 -05:00
endif ( )
2021-04-21 06:08:14 -05:00
install ( DIRECTORY doc/man1 DESTINATION ${ CMAKE_INSTALL_MANDIR }
F I L E S _ M A T C H I N G P A T T E R N " * . 1 " )
