OilfieldToolsNet/opm-simulators
4
0 Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2026-10-25 15:10:09 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
f76738b70844041969c879589fbbced2fbdb0303
opm-simulators/CMakeLists.txt
T

1006 lines
30 KiB
CMake
Raw Blame History

###########################################################################
# #
# 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 #
# #
###########################################################################
cmake_minimum_required (VERSION 3.23)
project(opm-simulators C CXX)
option(SIBLING_SEARCH "Search for other modules in sibling directories?" ON)
option(BUILD_FLOW "Build the production oriented flow simulator?" ON)
option(BUILD_FLOW_VARIANTS "Build the variants for flow by default?" ON)
option(BUILD_FLOW_FLOAT_VARIANTS "Build the variants for flow using float?" OFF)
option(BUILD_FLOW_POLY_GRID "Build flow blackoil with polyhedral grid" OFF)
option(OPM_ENABLE_PYTHON "Enable python bindings?" OFF)
option(OPM_ENABLE_PYTHON_TESTS "Enable tests for the python bindings?" ON)
option(OPM_INSTALL_PYTHON "Install python bindings?" ON)
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)
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)
option(BUILD_FLOW_ALU_GRID "Build flow blackoil with alu grid" OFF)
option(USE_DAMARIS_LIB "Use the Damaris library for asynchronous I/O?" OFF)
option(USE_GPU_BRIDGE "Enable the GPU bridge (GPU/AMGCL solvers)" ON)
option(CONVERT_CUDA_TO_HIP "Convert CUDA code to HIP (to run on AMD cards)" OFF)
option(SUPPRESS_HIPIFY_WARNINGS "Suppress warnings in hipify?" ON)
option(USE_AMGX "Enable AMGX support?" OFF)
option(USE_HYPRE "Use the Hypre library for linear solvers?" OFF)
set(OPM_COMPILE_COMPONENTS "2;3;4;5;6;7;8;9;10" CACHE STRING "The components to compile support for")
option(USE_OPENCL "Enable OpenCL support?" ON)
option(USE_DEV_SIMULATOR_IN_TESTS "Use the development simulator binaries in tests?" OFF)
# Wrapper for opm_add_target_options that also adds
# compile definitions and target links from the library
function(simulators_add_target_options)
cmake_parse_arguments(PARAM "" "TARGET" "" ${ARGN})
if(NOT PARAM_TARGET)
message(FATAL_ERROR "Function needs a TARGET parameter")
endif()
opm_add_target_options(TARGET ${PARAM_TARGET})
get_property(defs TARGET opmsimulators PROPERTY INTERFACE_COMPILE_DEFINITIONS)
target_compile_definitions(${PARAM_TARGET} PRIVATE ${defs})
get_property(libs TARGET opmsimulators PROPERTY INTERFACE_LINK_LIBRARIES)
target_link_libraries(${PARAM_TARGET} PRIVATE ${libs})
get_property(incs TARGET opmsimulators PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
target_include_directories(${PARAM_TARGET} PRIVATE ${incs})
if(TARGET opmcommon)
add_dependencies(${PARAM_TARGET} opmcommon)
endif()
# We only wait for the hipification process if we are compiling HIP.
# That is, we need to wait for the HIP header files to be generated
# before the rest of the code can compile. HIP header file includes
# anything in gpuistl, say.
if (CONVERT_CUDA_TO_HIP)
add_dependencies(${PARAM_TARGET} hipified_headers)
endif()
endfunction()
macro(opm-simulators_language_hook)
if(CONVERT_CUDA_TO_HIP)
message("CUDA code will be hipified")
enable_language(HIP)
endif()
# 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.
if(NOT CMAKE_DISABLE_FIND_PACKAGE_CUDA AND NOT CONVERT_CUDA_TO_HIP)
include(UseCUDA)
endif()
endmacro()
macro(opm-simulators_prereqs_hook)
if(MPI_FOUND AND HDF5_FOUND AND NOT HDF5_IS_PARALLEL)
message(
WARNING
"When building parallel OPM flow we need a "
"parallel version of hdf5, but found only a serial one. "
"Please install a parallel hdf5 library for MPI "
"(e.g with apt-get install libhdf5-mpi-dev) and do a clean "
"rebuild (build after \"make clean\"). Continuing with "
"only normal restart without hdf5 file support."
)
set(HDF5_FOUND OFF)
endif()
target_link_libraries(opmsimulators
PUBLIC
opmcommon
opmgrid
SuiteSparse::UMFPACK
Boost::date_time
)
if(TARGET ParMETIS::ParMETIS)
target_link_libraries(opmsimulators PUBLIC ParMETIS::ParMETIS)
elseif(MPI_FOUND)
message(
WARNING
"We have not found ParMETIS/PTScotch on your systems. "
"Please note that without this the parallel AMG will be less scalable. "
"It is advised to install PTScotch to fix this.")
endif()
if(MPI_FOUND)
target_link_libraries(opmsimulators PUBLIC MPI::MPI_C MPI::MPI_CXX)
endif()
if (TARGET fmt::fmt)
target_link_libraries(opmsimulators PUBLIC fmt::fmt)
else()
include(DownloadFmt)
DownloadFmt(opmsimulators)
endif()
if(HDF5_FOUND)
target_link_libraries(opmsimulators PUBLIC HDF5::HDF5)
target_compile_definitions(opmsimulators PUBLIC HAVE_HDF5=1)
endif()
if (OPM_ENABLE_PYTHON)
# Be backwards compatible.
if(PYTHON_EXECUTABLE AND NOT Python3_EXECUTABLE)
set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
endif()
find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
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()
find_package(pybind11 CONFIG)
if(NOT pybind11_FOUND)
include(DownloadPyBind11)
endif()
endif()
if(CONVERT_CUDA_TO_HIP)
find_package(hip REQUIRED)
find_package(hipsparse REQUIRED)
find_package(hipblas REQUIRED)
find_program(HIPIFY_PERL_COMMAND
NAMES hipify-perl
HINTS
PATH /opt/rocm/bin
)
if(HIPIFY_PERL_COMMAND)
add_executable(hipify-perl IMPORTED GLOBAL)
set_target_properties(hipify-perl
PROPERTIES IMPORTED_LOCATION ${HIPIFY_PERL_COMMAND}
)
else()
message(FATAL_ERROR "hipify-perl, required to convert CUDA to HIP, not found")
endif()
target_link_libraries(opmsimulators PUBLIC roc::hipblas roc::hipsparse)
endif()
if(USE_GPU_BRIDGE)
if(NOT CMAKE_DISABLE_FIND_PACKAGE_rocsparse)
find_package(rocalution)
find_package(rocblas)
find_package(rocsparse)
endif()
find_package(amgcl)
if(amgcl_FOUND)
target_compile_definitions(amgcl::amgcl INTERFACE HAVE_AMGCL=1)
target_link_libraries(opmsimulators PRIVATE amgcl::amgcl)
endif()
if(rocalution_FOUND)
target_compile_definitions(roc::rocalution INTERFACE HAVE_ROCALUTION=1)
target_link_libraries(opmsimulators PRIVATE roc::rocalution)
endif()
if(rocblas_FOUND AND rocsparse_FOUND)
target_compile_definitions(roc::rocblas INTERFACE HAVE_ROCBLAS=1)
target_compile_definitions(roc::rocsparse INTERFACE HAVE_ROCSPARSE=1)
target_link_libraries(opmsimulators PRIVATE roc::rocblas)
target_link_libraries(opmsimulators PRIVATE roc::rocsparse)
endif()
endif()
if(USE_GPU_BRIDGE AND rocsparse_FOUND AND NOT CMAKE_DISABLE_FIND_PACKAGE_CUDA)
message(WARNING
"GPU bridge: Using CUDA and ROCm at the same time is not allowed. "
"Since rocsparse was found, CUDA will be disabled. "
"Use -DCMAKE_DISABLE_FIND_PACKAGE_rocsparse=ON to instead use CUDA.")
set(CMAKE_DISABLE_FIND_PACKAGE_CUDA ON)
endif()
# 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.
if(NOT CMAKE_DISABLE_FIND_PACKAGE_CUDA AND NOT CONVERT_CUDA_TO_HIP)
if(CUDA_FOUND)
find_package(CUDAToolkit REQUIRED)
target_link_libraries(opmsimulators
PUBLIC
CUDA::cusparse
CUDA::cublas
CUDA::nvptxcompiler_static
)
endif()
endif()
# Find AMGX
if(USE_AMGX)
find_package(AMGX)
if(AMGX_FOUND)
target_link_libraries(opmsimulators PRIVATE AMGX::AMGX)
else()
message(WARNING "AMGX requested but not found. Continuing without AMGX support.")
endif()
endif()
if(USE_HYPRE AND USE_MPI)
find_package(HYPRE)
if(HYPRE_FOUND)
target_link_libraries(opmsimulators PUBLIC HYPRE::HYPRE)
else()
message(WARNING "Hypre requested but not found. Continuing without Hypre support.")
endif()
elseif(USE_HYPRE)
message(WARNING "Hypre requested but MPI not activated. Continuing without Hypre support.")
endif()
if(USE_OPENCL AND USE_GPU_BRIDGE)
find_package(OpenCL)
if(OpenCL_FOUND)
# the current OpenCL implementation relies on cl2.hpp, not cl.hpp
# make sure it is available, otherwise disable OpenCL
find_file(CL2_HPP CL/cl2.hpp HINTS ${OpenCL_INCLUDE_DIRS})
if(NOT CL2_HPP)
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"
)
set(OpenCL_FOUND OFF)
else()
target_compile_definitions(OpenCL::OpenCL INTERFACE HAVE_OPENCL=1)
find_file(OPENCL_HPP CL/opencl.hpp HINTS ${OpenCL_INCLUDE_DIRS})
if(OPENCL_HPP)
target_compile_definitions(OpenCL::OpenCL INTERFACE HAVE_OPENCL_HPP=1)
endif()
target_link_libraries(opmsimulators PRIVATE OpenCL::OpenCL)
endif()
elseif(USE_CHOW_PATEL_ILU)
message(FATAL_ERROR " CHOW_PATEL_ILU only works for openclSolver, but OpenCL was not found")
endif()
if(OpenCL_FOUND)
find_package(VexCL)
if(VexCL_FOUND)
# VexCL sets c++ specific flags. Remove so we don't get warnings in .c sources
get_target_property(compile_opts VexCL::Common INTERFACE_COMPILE_OPTIONS)
list(FILTER compile_opts EXCLUDE REGEX .*-Wno-catch-value.*)
set_property(TARGET VexCL::Common PROPERTY INTERFACE_COMPILE_OPTIONS ${compile_opts})
target_compile_definitions(VexCL::Common INTERFACE HAVE_VEXCL=1)
target_link_libraries(opmsimulators PRIVATE VexCL::Common VexCL::OpenCL)
endif()
endif()
endif()
if(TARGET dunealugrid)
target_link_libraries(opmsimulators PUBLIC dunealugrid)
endif()
if(TARGET dunefem)
target_link_libraries(opmsimulators PUBLIC dunefem)
endif()
if(USE_DAMARIS_LIB AND MPI_FOUND)
find_package(Damaris 1.9)
if (Damaris_FOUND)
target_link_libraries(opmsimulators PUBLIC damaris)
endif()
endif()
include(CheckAVX2)
check_for_avx2()
endmacro()
macro(opm-simulators_sources_hook)
if(OpenCL_FOUND)
include(opencl-source-provider)
target_sources(opmsimulators PRIVATE ${PROJECT_BINARY_DIR}/clSources.cpp)
endif()
if(QuadMath_FOUND)
get_target_property(qm_defs QuadMath::QuadMath INTERFACE_COMPILE_DEFINITIONS)
get_target_property(qm_options QuadMath::QuadMath INTERFACE_COMPILE_OPTIONS)
if(qm_defs)
list(APPEND qm_defs HAVE_QUAD=1)
else()
set(qm_defs HAVE_QUAD=1)
endif()
foreach(source opm/models/nonlinear/newtonmethodparams.cpp
opm/models/utils/parametersystem.cpp
opm/models/utils/simulatorutils.cpp
)
set_property(
SOURCE
${source}
APPEND PROPERTY
COMPILE_DEFINITIONS
${qm_defs}
)
set_property(
SOURCE
${source}
APPEND PROPERTY
COMPILE_OPTIONS
${qm_options}
)
endforeach()
endif()
if(HYPRE_FOUND)
list(APPEND tests_SOURCES tests/test_HyprePreconditionerCPU.cpp)
list(APPEND tests_SOURCES tests/gpuistl/test_HypreInterfaceCPU.cpp)
if(HYPRE_USING_CUDA OR HYPRE_USING_HIP)
list(APPEND tests_SOURCES tests/test_HyprePreconditionerGPU.cpp)
list(APPEND tests_SOURCES tests/gpuistl/test_HypreInterfaceGPU.cpp)
endif()
endif()
if(AMGX_FOUND)
list(APPEND tests_SOURCES tests/gpuistl/test_AmgxInterface.cpp)
list(APPEND tests_SOURCES tests/test_AmgxPreconditioner.cpp)
endif()
if(HAVE_AVX2_EXTENSION)
set_property(SOURCE ${AVX2_SOURCE_FILES} PROPERTY COMPILE_OPTIONS ${AVX2_FLAGS})
target_compile_definitions(opmsimulators PUBLIC HAVE_AVX2_EXTENSION=1)
endif()
# Boost 1.66 used on RHEL8 cannot be built as c++-20
if(Boost_VERSION VERSION_LESS 1.67)
set_source_files_properties(
opm/simulators/linalg/PropertyTree.cpp
opm/simulators/utils/SetupPartitioningParams.cpp
PROPERTIES
COMPILE_OPTIONS
-std=c++17
)
if(amgcl_FOUND AND USE_GPU_BRIDGE)
set_source_files_properties(
opm/simulators/linalg/gpubridge/amgclSolverBackend.cpp
opm/simulators/linalg/gpubridge/GpuBridge.cpp
PROPERTIES
COMPILE_OPTIONS
-std=c++17
)
endif()
endif()
if(CUDA_FOUND)
# cuda warns when constxpr functions are used in kernels.
# since the entire stl is constexpr ..., we enable relaxed flag
set_source_files_properties(
tests/gpuistl/test_blackoilfluidstategpu.cu
tests/gpuistl/test_gpu_ad.cu
tests/gpuistl/test_gpu_linear_two_phase_material.cu
tests/gpuistl/test_gpuPvt.cu
tests/gpuistl/test_gpuBlackOilFluidSystem.cu
tests/gpuistl/test_GpuSparseMatrix.cu
tests/gpuistl/test_GpuSparseTable.cu
tests/gpuistl/test_MiniMatrix.cu
tests/gpuistl/test_MiniVector.cu
PROPERTIES
COMPILE_OPTIONS
--expt-relaxed-constexpr
)
# Certain structures in OPM requires the -fpermissive flag to compile with nvcc,
# this enables this for the specific files
set_source_files_properties(
tests/gpuistl/test_primary_variables_gpu.cu
PROPERTIES
COMPILE_OPTIONS
"-fpermissive;-Xcompiler=-fpermissive;--expt-relaxed-constexpr"
)
endif()
endmacro()
macro(opm-simulators_config_hook)
if(BUILD_FLOW_FLOAT_VARIANTS)
target_compile_definitions(opmsimulators
PRIVATE
FLOW_INSTANTIATE_FLOAT=1
)
endif()
# The parameter system can leverage std::from_chars() for
# floating-point types if available. Detect support for this
# feature.
try_compile(
have_float_from_chars
${CMAKE_BINARY_DIR}
${PROJECT_SOURCE_DIR}/cmake/test/testFloatFromChars.cpp
CXX_STANDARD 17
)
if(have_float_from_chars)
set_property(
SOURCE
opm/models/utils/parametersystem.cpp
APPEND PROPERTY
COMPILE_DEFINITIONS
HAVE_FLOATING_POINT_FROM_CHARS=1
)
endif()
if (Damaris_FOUND AND MPI_FOUND AND USE_DAMARIS_LIB)
target_compile_definitions(opmsimulators PUBLIC HAVE_DAMARIS=1)
endif()
if(CONVERT_CUDA_TO_HIP)
target_compile_definitions(opmsimulators
PUBLIC
HAVE_CUDA=1
USE_HIP=1
)
endif()
if(CUDA_FOUND)
target_compile_definitions(opmsimulators PUBLIC HAVE_CUDA=1)
endif()
if(USE_GPU_BRIDGE)
target_compile_definitions(opmsimulators PUBLIC COMPILE_GPU_BRIDGE=1)
endif()
if(OpenCL_FOUND)
if( USE_CHOW_PATEL_ILU)
target_compile_definitions(opmsimulators PRIVATE CHOW_PATEL=1)
elseif(USE_CHOW_PATEL_ILU_GPU)
target_compile_definitions(opmsimulators PRIVATE CHOW_PATEL_GPU=1)
if(USE_CHOW_PATEL_ILU_GPU_PARALLEL)
target_compile_definitions(opmsimulators PRIVATE CHOW_PATEL_GPU_PARALLEL=1)
endif()
endif()
endif()
endmacro()
macro(opm-simulators_tests_hook)
include(${CMAKE_CURRENT_SOURCE_DIR}/modelTests.cmake)
# Look for the opm-tests repository; if found the variable
# HAVE_OPM_TESTS will be set to true.
include(Findopm-tests)
if (HAVE_OPM_TESTS)
include(${CMAKE_CURRENT_SOURCE_DIR}/compareECLFiles.cmake)
endif()
if(MPI_FOUND)
include(${CMAKE_CURRENT_SOURCE_DIR}/parallelUnitTests.cmake)
endif()
if(OPM_ENABLE_PYTHON)
include(${CMAKE_CURRENT_SOURCE_DIR}/pythonIntegrationTests.cmake)
endif()
if(CUDA_FOUND OR hip_FOUND)
# CUISTL
set(gpu_label "gpu_cuda")
if(CONVERT_CUDA_TO_HIP)
set(gpu_label "gpu_hip")
endif()
foreach(test
AmgxInterface
AmgxPreconditioner
blackoilfluidstategpu
conditional_storage
cublas_handle
cublas_safe_call
cuda_check_last_error
cusparse_handle
cuSparse_matrix_operations
cusparse_safe_call
cusparseSolver
cuVector_operations
deviceBlockOperations
gpu_ad
gpu_linear_two_phase_material
gpu_resources
gpu_safe_call
gpu_smart_pointers
gpuBlackOilFluidSystem
GpuBuffer
GpuDILU
GpuJac
GpuOwnerOverlapCopy
GpuPressureTransferPolicy
gpuPvt
GpuSeqILU0
GpuSparseMatrix
GpuSparseTable
GpuVector
GpuView
HypreInterfaceGPU
HyprePreconditionerGPU
is_gpu_pointer
MiniMatrix
MiniVector
preconditioner_factory_gpu
primary_variables_gpu
solver_adapter
throw_macros_on_gpu
)
if(TEST ${test})
set_tests_properties(${test}
PROPERTIES
LABELS
${gpu_label}
)
endif()
endforeach()
endif()
if(USE_GPU_BRIDGE)
if(OpenCL_FOUND)
set_tests_properties(
openclSolver
solvetransposed3x3
csrToCscOffsetMap
PROPERTIES
LABELS
gpu_opencl
)
endif()
if(rocalution_FOUND)
set_tests_properties(rocalutionSolver PROPERTIES LABELS gpu_rocm)
target_link_libraries(test_rocalutionSolver PRIVATE roc::rocalution)
endif()
if(rocsparse_FOUND AND rocblas_FOUND)
set_tests_properties(rocsparseSolver PROPERTIES LABELS gpu_rocm)
target_link_libraries(test_rocsparseSolver PRIVATE roc::rocsparse roc::rocblas)
endif()
endif()
add_custom_target(extra_test ${CMAKE_CTEST_COMMAND} -C ExtraTests)
if(HAVE_OPM_TESTS)
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
USES_TERMINAL
COMMAND ${CMAKE_COMMAND} -E env "PYTHONPATH=${opm-common_DIR}/python"
${PROJECT_SOURCE_DIR}/tests/make_failure_report.sh
${OPM_TESTS_ROOT} ${CMAKE_BINARY_DIR} ${sim_dir})
endif()
endif()
if(BUILD_FLOW)
add_test(
NAME
flow__version
COMMAND
$<TARGET_FILE:flow> --version
)
set_tests_properties(flow__version
PROPERTIES
PASS_REGULAR_EXPRESSION
${${project}_LABEL}
)
endif()
endmacro()
macro(opm-simulators_targets_hook)
# 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_executable(
TARGET
lens_immiscible_ecfv_ad_mcu
SOURCES
examples/lens_immiscible_ecfv_ad_cu1.cpp
examples/lens_immiscible_ecfv_ad_cu2.cpp
examples/lens_immiscible_ecfv_ad_main.cpp
LIBRARIES
opmsimulators
)
opm_add_executable(
TARGET
test_tuning_trgmbe
SOURCES
tests/test_tuning_TRGMBE.cpp
LIBRARIES
Boost::unit_test_framework
)
opm_add_executable(
TARGET
test_tuning_tsinit_nextstep
SOURCES
tests/test_tuning_TSINIT_NEXTSTEP.cpp
LIBRARIES
opmcommon
Boost::unit_test_framework
)
if(QuadMath_FOUND)
foreach(tapp co2injection_flash_ni_ecfv
co2injection_flash_ni_vcfv
co2injection_flash_ecfv
co2injection_flash_vcfv)
opm_add_executable(
TARGET
${tapp}_quad
LIBRARIES
QuadMath::QuadMath
opmsimulators
SOURCES
examples/${tapp}.cpp
)
target_compile_definitions(${tapp}_quad PRIVATE HAVE_QUAD=1)
endforeach()
endif()
if(CUDA_FOUND)
foreach(tgt
test_gpu_safe_call
test_cuda_check_last_error
test_GpuVector
test_is_gpu_pointer)
target_link_libraries(${tgt} PRIVATE CUDA::cudart)
endforeach()
endif()
if(OpenCL_FOUND)
target_link_libraries(test_solvetransposed3x3 PRIVATE OpenCL::OpenCL)
target_link_libraries(test_csrToCscOffsetMap PRIVATE OpenCL::OpenCL)
endif()
opm_add_library(
TARGET
moduleVersion
TYPE
OBJECT
SOURCES
opm/simulators/utils/moduleVersion.cpp
)
# Strictly we only depend on the update-version target,
# but this is not exposed in a super-build.
add_dependencies(moduleVersion opmsimulators)
opm_add_library(
TARGET
MainDispatchDynamic
TYPE
OBJECT
SOURCES
opm/simulators/flow/MainDispatchDynamic.cpp
)
simulators_add_target_options(TARGET MainDispatchDynamic)
target_sources(test_outputdir PRIVATE $<TARGET_OBJECTS:moduleVersion>)
target_sources(test_equil PRIVATE $<TARGET_OBJECTS:moduleVersion>)
target_sources(test_group_higher_constraints PRIVATE $<TARGET_OBJECTS:moduleVersion>)
target_sources(test_injection_topup_phase_validation PRIVATE $<TARGET_OBJECTS:moduleVersion>)
target_sources(test_RestartSerialization PRIVATE $<TARGET_OBJECTS:moduleVersion>)
target_sources(test_glift1 PRIVATE $<TARGET_OBJECTS:moduleVersion>)
target_sources(test_tpsa_localresidual PRIVATE $<TARGET_OBJECTS:moduleVersion>)
if(MPI_FOUND)
target_sources(test_chopstep PRIVATE $<TARGET_OBJECTS:moduleVersion>)
endif()
set(FLOW_MODELS
blackoil
blackoil_legacyassembly
blackoil_nohyst
blackoil_temp
blackoil_tpsa
biofilm
brine
brine_energy
brine_precsalt_vapwat
brine_saltprecipitation
energy
extbo
foam
gasoil
gasoildiffuse
gasoil_energy
gaswater
gaswater_brine
gaswater_dissolution
gaswater_dissolution_diffuse
gaswater_dissolution_tpsa
gaswater_energy
gaswater_saltprec_energy
gaswater_saltprec_vapwat
gaswater_solvent
micp
oilwater
oilwater_brine
oilwater_polymer
oilwater_polymer_injectivity
onephase
onephase_energy
onephase_tpsa
polymer
solvent
solvent_foam
)
foreach(OBJ ${COMMON_MODELS} ${FLOW_MODELS} ${FLOW_VARIANT_MODELS})
opm_add_library(
TARGET
flow_lib${OBJ}
TYPE
OBJECT
SOURCES
flow/flow_${OBJ}.cpp
)
simulators_add_target_options(TARGET flow_lib${OBJ})
list(APPEND FLOW_TGTS $<TARGET_OBJECTS:flow_lib${OBJ}>)
list(APPEND FLOWMODELS_PREFIXED flow_${OBJ})
opm_add_executable(
TARGET
flow_${OBJ}
SOURCES
flow/flow_${OBJ}_main.cpp
$<TARGET_OBJECTS:moduleVersion>
$<TARGET_OBJECTS:flow_lib${OBJ}>
LIBRARIES
opmsimulators
)
endforeach()
opm_add_executable(
TARGET
flow
SOURCES
flow/flow.cpp
${FLOW_TGTS}
$<TARGET_OBJECTS:moduleVersion>
$<TARGET_OBJECTS:MainDispatchDynamic>
LIBRARIES
opmsimulators
)
opm_add_executable(
TARGET
flow_distribute_z
SOURCES
flow/flow_distribute_z.cpp
${FLOW_TGTS}
$<TARGET_OBJECTS:moduleVersion>
$<TARGET_OBJECTS:MainDispatchDynamic>
LIBRARIES
opmsimulators
)
# Flow GPU executables handled separately to avoid making flow dependent on CUDA/HIP
set(FLOW_GPU_MODELS
gpu_gaswater_thermal
)
if(CONVERT_CUDA_TO_HIP OR CUDA_FOUND)
if(CONVERT_CUDA_TO_HIP)
set(EXTENSION "hip")
else()
set(EXTENSION "cu")
endif()
foreach(OBJ ${FLOW_GPU_MODELS})
opm_add_library(
TARGET
flow_lib${OBJ}
TYPE
OBJECT
SOURCES
flow/flow_${OBJ}.${EXTENSION}
)
simulators_add_target_options(TARGET flow_lib${OBJ})
list(APPEND FLOW_GPU_TGTS $<TARGET_OBJECTS:flow_lib${OBJ}>)
list(APPEND FLOWMODELS_PREFIXED flow_${OBJ})
opm_add_executable(
TARGET
flow_${OBJ}
SOURCES
flow/flow_${OBJ}_main.cpp
$<TARGET_OBJECTS:moduleVersion>
$<TARGET_OBJECTS:flow_lib${OBJ}>
LIBRARIES
opmsimulators
)
endforeach()
opm_add_executable(
TARGET
flow_gpu
SOURCES
flow/flow_gpu_main.cpp
${FLOW_GPU_TGTS}
$<TARGET_OBJECTS:moduleVersion>
LIBRARIES
opmsimulators
)
endif()
if(OPM_ENABLE_PYTHON)
set_target_properties(
flow_libblackoil
moduleVersion
MainDispatchDynamic
PROPERTIES
POSITION_INDEPENDENT_CODE
ON
)
add_subdirectory(python/simulators)
endif()
# 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)
list(APPEND FLOWEXP_COMPONENTS_SOURCES flowexperimental/comp/flowexp_comp${component}_2p.cpp)
endforeach()
# 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}")
opm_add_executable(
TARGET
flowexp_comp
SOURCES
flowexperimental/comp/flowexp_comp.cpp
${FLOWEXP_COMPONENTS_SOURCES}
$<TARGET_OBJECTS:moduleVersion>
LIBRARIES
opmsimulators
)
target_compile_definitions(flowexp_comp
PRIVATE
OPM_COMPILE_COMPONENTS_TEMPLATE_LIST=${OPM_COMPILE_COMPONENTS_TEMPLATE_LIST}
)
if(BUILD_FLOW_FLOAT_VARIANTS)
opm_add_executable(
TARGET
flow_blackoil_float
SOURCES
flow/flow_blackoil_float_main.cpp
$<TARGET_OBJECTS:moduleVersion>
LIBRARIES
opmsimulators
)
endif()
opm_add_executable(
TARGET
flowexp_blackoil
SOURCES
flowexperimental/flowexp_blackoil.cpp
$<TARGET_OBJECTS:moduleVersion>
LIBRARIES
opmsimulators
)
if(dune-alugrid_FOUND AND BUILD_FLOW_ALU_GRID)
opm_add_executable(
TARGET
flow_blackoil_alugrid
SOURCES
flow/flow_blackoil_alugrid.cpp
$<TARGET_OBJECTS:moduleVersion>
LIBRARIES
opmsimulators
)
endif()
if(BUILD_FLOW_POLY_GRID)
opm_add_executable(
TARGET
flow_blackoil_polyhedralgrid
SOURCES
flow/flow_blackoil_polyhedralgrid.cpp
$<TARGET_OBJECTS:moduleVersion>
LIBRARIES
opmsimulators
)
endif()
if(NOT BUILD_FLOW_VARIANTS)
foreach(target flowexp_blackoil
flowexp_comp
flow_blackoil_alugrid
flow_blackoil_float
flow_blackoil_polyhedralgrid
${FLOWMODELS_PREFIXED})
if(TARGET ${target})
set_target_properties(${target}
PROPERTIES
EXCLUDE_FROM_ALL ON
)
endif()
endforeach()
endif()
endmacro()
macro(opm-simulators_install_hook)
install(
DIRECTORY
doc/man1
DESTINATION
${CMAKE_INSTALL_MANDIR}
FILES_MATCHING PATTERN
"*.1"
)
if (BUILD_FLOW)
install(TARGETS flow DESTINATION bin)
include(OpmBashCompletion)
opm_add_bash_completion(flow)
endif()
endmacro()
# 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()
# Check that OPM_COMPILE_COMPONENTS is a subset of 2,3,4,5,6,7,8,9,10
set(valid_components "2;3;4;5;6;7;8;9;10")
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)
if(CONVERT_CUDA_TO_HIP)
set(USE_GPU_BRIDGE OFF)
endif()
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})
set(opm-grid_DIR ${_modules_dir}/opm-grid/${_leaf_dir_name})
else()
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})
string(REPLACE ${PROJECT_NAME} opm-grid _opm_grid_leaf ${_leaf_dir_name})
set(opm-grid_DIR ${_parent_full_dir}/${_opm_grid_leaf})
elseif(IS_DIRECTORY ${_parent_full_dir}/opm-common)
# All modules are in a common build dir
set(opm-common_DIR "${_parent_full_dir}/opm-common")
set(opm-grid_DIR "${_parent_full_dir}/opm-grid")
endif()
endif()
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")
endif()
find_package(opm-common REQUIRED)
# 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)
# all setup common to the OPM library modules is done here
include (OpmLibMain)
Reference in new issue View Git Blame Copy Permalink