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

214 lines
6.6 KiB
CMake
Raw Normal View History

Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
# -*- mode: cmake; tab-width: 2; indent-tabs-mode: t; truncate-lines: t; compile-command: "cmake -Wdev" -*-
# vim: set filetype=cmake autoindent tabstop=2 shiftwidth=2 noexpandtab softtabstop=2 nowrap:
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
changed: put prereqs in module itself
2017-12-19 05:44:24 -06:00
project(opm-simulators C CXX)
Introduced mandatory call to project in top level CMakeLists.txt Somehow this was never called in the OPM modules. But the CMake documentation actually says: "The top-level ``CMakeLists.txt`` file for a project must contain a literal, direct call to the ``project()`` command; loading one through the ``include()`` command is not sufficient. If no such call exists CMake will implicitly add one to the top that enables the default languages (``C`` and ``CXX``). " Without it some variables (like CMAKE_PROJECT_NAME) are not correctly defined.
2017-09-15 04:17:40 -05:00
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
cmake_minimum_required (VERSION 2.8)
added: 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
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
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)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
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
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)
Support older versions of Dune Retrieving the "mpihelper.hh" from <dune/common> rather than <dune/common/parallel> means we can still support (e.g.,) Dune 2.2.1 if needed.
2014-04-09 17:59:31 -05:00
opm_need_version_of ("dune-common")
Obtain dune-istl version for config.h. Required by DuneMatrix.hpp.
2014-09-30 06:46:01 -05:00
opm_need_version_of ("dune-istl")
add flow_ebos, an ebos based simulator it uses ebos for linearization of the mass balance equations and the current flow code from opm-simulators for all the rest. currently, the results match the ones from plain `flow` for SPE1, SPE9 and Norne, but performance is not optimal: on SPE9, converting from and to the legacy data structures takes about a third of the time to do the actual mass balance assembly. nevertheless `flow_ebos` is almost as fast as plain `flow` for SPE9. (for Norne `flow_ebos` is about 15% slower, even though the results match quite closely. the reason for this is that it requires more iterations for some reason.)
2016-06-06 08:40:06 -05:00
opm_need_version_of ("ewoms")
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
endmacro (config_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (prereqs_hook)
endmacro (prereqs_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (sources_hook)
endmacro (sources_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (fortran_hook)
endmacro (fortran_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
added: hook for conditionally compiled files backport from opm-upscaling PR#100
2014-06-16 07:40:52 -05:00
macro (files_hook)
endmacro (files_hook)
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
macro (tests_hook)
endmacro (tests_hook)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
Separate build concerns for better maintainability Introduce a main build file which uses modules in the cmake/ directory for most of its bulk work, which agains retrieve information from files in the root of the source tree (dune.module, CMakeLists_files.cmake) to get information about the project. Thus, the cmake/ directory is shared between all the projects down to the last bit; only project-specific customizations go into the main file in form of _hook macros (which are called in specific places).
2013-08-02 07:07:33 -05:00
# all setup common to the OPM library modules is done here
include (OpmLibMain)
Complete import of CMake support from OPM-Core
2013-05-15 03:40:00 -05:00
use opm-tests
2018-03-12 09:37:21 -05:00
if (HAVE_OPM_TESTS)
Remove python tests.
2016-11-21 11:02:21 -06:00
include (${CMAKE_CURRENT_SOURCE_DIR}/compareECLFiles.cmake)
changed: move multisegment well test to proper regression test
2017-03-03 08:08:12 -06:00
endif()
added: install bash tab completion for flow
2018-09-19 04:45:40 -05:00
Run the "gatherconvergencereport" test in parallel.
2018-11-13 03:28:05 -06:00
opm_set_test_driver(${CMAKE_CURRENT_SOURCE_DIR}/tests/run-parallel-unitTest.sh "")
opm_add_test(test_gatherconvergencereport
DEPENDS "opmsimulators"
LIBRARIES opmsimulators ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}
SOURCES
tests/test_gatherconvergencereport.cpp
CONDITION
MPI_FOUND
DRIVER_ARGS
5 ${CMAKE_BINARY_DIR}
)
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
MPI_FOUND
DRIVER_ARGS
5 ${CMAKE_BINARY_DIR}
)
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
# the production oriented general-purpose ECL simulator
make the build of flow fully parallelizable so far, the actual specializations of the simulator were compiled into the `libopmsimulators` library and the build of the glue code (`flow.cpp`) thus needed to be deferred until the library was fully built. Since the compilation of the glue code requires a full property hierarchy for handling command line parameters, this arrangement significantly increases the build time for systems with a sufficient number of parallel build processes. ("sufficient" here means 8 or more threads, i.e., a quadcore system with hyperthreading is sufficient provided that it has enough main memory.) the new approach is not to include these objects in `libopmsimulators`, but to directly deal with them in the `flow` binary. this allows all of them and the glue code to be compiled in parallel. compilation time on my machine before this change: ``` > touch ../opm/autodiff/BlackoilModelEbos.hpp; time make -j32 flow 2> /dev/null Scanning dependencies of target opmsimulators [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_gasoil.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_oilwater.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_blackoil.cpp.o [ 2%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_solvent.cpp.o [ 4%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_polymer.cpp.o [ 6%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_energy.cpp.o [ 6%] Building CXX object CMakeFiles/opmsimulators.dir/opm/simulators/flow_ebos_oilwater_polymer.cpp.o [ 6%] Linking CXX static library lib/libopmsimulators.a [ 97%] Built target opmsimulators Scanning dependencies of target flow [100%] Building CXX object CMakeFiles/flow.dir/examples/flow.cpp.o [100%] Linking CXX executable bin/flow [100%] Built target flow real 1m45.692s user 8m47.195s sys 0m11.533s ``` after: ``` > touch ../opm/autodiff/BlackoilModelEbos.hpp; time make -j32 flow 2> /dev/null [ 91%] Built target opmsimulators Scanning dependencies of target flow [ 93%] Building CXX object CMakeFiles/flow.dir/flow/flow.cpp.o [ 95%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_gasoil.cpp.o [ 97%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_oilwater_polymer.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_polymer.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_oilwater.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_solvent.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_blackoil.cpp.o [100%] Building CXX object CMakeFiles/flow.dir/flow/flow_ebos_energy.cpp.o [100%] Linking CXX executable bin/flow [100%] Built target flow real 1m21.597s user 8m49.476s sys 0m10.973s ``` (this corresponds to a ~20% reduction of the time spend on waiting for the compiler.)
2018-09-20 03:58:27 -05:00
opm_add_test(flow
ONLY_COMPILE
ALWAYS_ENABLE
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators"
SOURCES
flow/flow.cpp
flow/flow_ebos_blackoil.cpp
flow/flow_ebos_gasoil.cpp
flow/flow_ebos_oilwater.cpp
flow/flow_ebos_polymer.cpp
flow/flow_ebos_solvent.cpp
flow/flow_ebos_energy.cpp
adding flow_injecitivity executable target
2018-11-28 03:41:39 -06:00
flow/flow_ebos_oilwater_polymer.cpp
flow/flow_ebos_oilwater_polymer_injectivity.cpp)
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
install(TARGETS flow DESTINATION bin)
Add cmake test for the --version switch
2018-12-09 14:15:59 -06:00
add_test(NAME flow__version
COMMAND flow --version)
set_tests_properties(flow__version PROPERTIES
PASS_REGULAR_EXPRESSION "${${project}_LABEL}")
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
# the research oriented general-purpose ECL simulator ("ebos" == &ecl
# &black-&oil &simulator)
opm_add_test(ebos
fix the default build system for some reason, libraries produced for a module are not linked to the executables of the module by the default build system. so far this did not matter for `ebos` but with this PR, it starts using stuff from `libopmsimulators`...
2019-03-04 08:38:07 -06:00
ONLY_COMPILE
ALWAYS_ENABLE
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
EXE_NAME ebos
fix the default build system for some reason, libraries produced for a module are not linked to the executables of the module by the default build system. so far this did not matter for `ebos` but with this PR, it starts using stuff from `libopmsimulators`...
2019-03-04 08:38:07 -06:00
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators"
SOURCES ebos/ebos.cc)
Add cmake test for the --version switch
2018-12-09 14:15:59 -06:00
add some ebos variants these variants should cover most of the common use cases. That said, there are no plans to provide simulators for combinations of blackoil extensions or a "multiplexing" simulator like `flow`: If someone is interested in e.g., an oil-water simulator with polymer and energy enabled, a separate self-compiled executable should be added locally.
2019-03-05 04:41:02 -06:00
opm_add_test(ebos_solvent
ONLY_COMPILE
ALWAYS_ENABLE
SOURCES ebos/ebos_solvent.cc
EXE_NAME ebos_solvent
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
opm_add_test(ebos_polymer
ONLY_COMPILE
ALWAYS_ENABLE
SOURCES ebos/ebos_polymer.cc
EXE_NAME ebos_polymer
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
opm_add_test(ebos_gasoil
ONLY_COMPILE
ALWAYS_ENABLE
SOURCES ebos/ebos_gasoil.cc
EXE_NAME ebos_gasoil
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
opm_add_test(ebos_oilwater
ONLY_COMPILE
ALWAYS_ENABLE
SOURCES ebos/ebos_oilwater.cc
EXE_NAME ebos_oilwater
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
opm_add_test(ebos_thermal
ONLY_COMPILE
ALWAYS_ENABLE
SOURCES ebos/ebos_thermal.cc
EXE_NAME ebos_thermal
DEPENDS "opmsimulators"
LIBRARIES "opmsimulators")
CMakeLists.txt: remove unecessary condition thanks to [at]akva2 for catching this.
2019-03-04 08:42:57 -06:00
install(TARGETS ebos DESTINATION bin)
add some ebos variants these variants should cover most of the common use cases. That said, there are no plans to provide simulators for combinations of blackoil extensions or a "multiplexing" simulator like `flow`: If someone is interested in e.g., an oil-water simulator with polymer and energy enabled, a separate self-compiled executable should be added locally.
2019-03-05 04:41:02 -06:00
install(TARGETS ebos_solvent DESTINATION bin)
install(TARGETS ebos_polymer DESTINATION bin)
install(TARGETS ebos_gasoil DESTINATION bin)
install(TARGETS ebos_oilwater DESTINATION bin)
install(TARGETS ebos_thermal DESTINATION bin)
Add cmake test for the --version switch
2018-12-09 14:15:59 -06:00
added: install bash tab completion for flow
2018-09-19 04:45:40 -05:00
include(OpmBashCompletion)
opm_add_bash_completion(flow)
make the build system happy about the imported ebos binary also, a few data files changed their location.
2019-02-27 15:34:10 -06:00
opm_add_bash_completion(ebos)
Reference in New Issue Copy Permalink