bump versions to 2017.10 final

before OPM/opm-simulators#1309 it was required, but this was not
enforced by the build system because the SuiteSparse tests are run by
the opm-core build system first and UMFpack is optional there.

thanks to [at]akva2 and [at]blattms for the heads-up.

.gitignore

@@ -44,28 +44,3 @@ Testing/
 
 # Build directory in source.
 build/
-
-gmon.out
-log.log
-build
-install
-.cproject
-.project
-/testdata/statoil
-.idea
-/Debug/
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-
-# Mac OS X debug info
-*.dSYM
-
-# emacs directory setting:
-.dir-locals.el

.travis.yml

@@ -0,0 +1,39 @@
+language: cpp
+
+compiler:
+  - gcc
+
+addons:
+  apt:
+    sources:
+      - boost-latest
+      - ubuntu-toolchain-r-test
+      - george-edison55-precise-backports
+    packages:
+      - libboost1.55-all-dev
+      - gcc-4.8
+      - g++-4.8
+      - gfortran-4.8
+      - liblapack-dev
+      - libgmp3-dev
+      - libsuitesparse-dev
+      - libeigen3-dev
+      - bc
+      - cmake
+      - cmake-data
+
+env:
+  global:
+  - TRAVIS_CI=1
+
+
+before_script:
+    - export CXX="g++-4.8" CC="gcc-4.8" FC="gfortran-4.8"
+    - cd ..
+    - opm-common/travis/build-prereqs.sh
+    - opm-common/travis/clone-opm.sh opm-common
+    
+
+script: opm-common/travis/build-and-test.sh opm-common
+
+

CMakeLists.txt

@@ -1,58 +1,25 @@
-project(opm-common C CXX)
 cmake_minimum_required (VERSION 2.8)
 
 option(SIBLING_SEARCH "Search for other modules in sibling directories?" ON)
 list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules)
 set(OPM_MACROS_ROOT ${PROJECT_SOURCE_DIR})
 
-option(ENABLE_ECL_INPUT "Enable eclipse input support?" ON)
-option(ENABLE_ECL_OUTPUT "Enable eclipse output support?" ON)
-
-# Output implies input
-if(ENABLE_ECL_OUTPUT)
-  set(ENABLE_ECL_INPUT ON)
-endif()
-
-# And likewise, no input means no output
-if(NOT ENABLE_ECL_INPUT)
-  set(ENABLE_ECL_OUTPUT OFF)
-endif()
-
 # not the same location as most of the other projects; this hook overrides
 macro (dir_hook)
 endmacro (dir_hook)
 
 # We need to define this variable in the installed cmake config file.
-set(OPM_PROJECT_EXTRA_CODE_INSTALLED  "#ENABLE_ECL_INPUT is needed by opm-common-prereq.cmake
-                                       set(ENABLE_ECL_INPUT ${ENABLE_ECL_INPUT})
-                                       set(OPM_MACROS_ROOT ${CMAKE_INSTALL_PREFIX}/share/opm)
-                                       list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)
-                                       include(OpmPackage) #Make macros availabe after find_package(opm-common)")
+set(OPM_PROJECT_EXTRA_CODE_INSTALLED  "set(OPM_MACROS_ROOT ${CMAKE_INSTALL_PREFIX}/share/opm)
+                                       list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)")
 
-set(OPM_PROJECT_EXTRA_CODE_INTREE "#ENABLE_ECL_INPUT is needed by opm-common-prereq.cmake
-                                   set(ENABLE_ECL_INPUT ${ENABLE_ECL_INPUT})
-                                   set(OPM_MACROS_ROOT ${OPM_MACROS_ROOT})
-                                   list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)
-                                   include(OpmPackage) #Make macros availabe after find_package(opm-common)")
-if(ENABLE_ECL_OUTPUT)
-  set(OPM_PROJECT_EXTRA_CODE_INSTALLED "${OPM_PROJECT_EXTRA_CODE_INSTALLED}
-                                        set(COMPARE_SUMMARY_COMMAND ${CMAKE_INSTALL_PREFIX}/bin${${name}_VER_DIR}/compareSummary)
-                                        set(COMPARE_ECL_COMMAND ${CMAKE_INSTALL_PREFIX}/bin${${name}_VER_DIR}/compareECL)")
-
-  set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
-                                     set(COMPARE_SUMMARY_COMMAND ${PROJECT_BINARY_DIR}/bin/compareSummary)
-                                     set(COMPARE_ECL_COMMAND ${PROJECT_BINARY_DIR}/bin/compareECL)")
-endif()
+set(OPM_PROJECT_EXTRA_CODE_INTREE  "set(OPM_MACROS_ROOT ${OPM_MACROS_ROOT})
+                                    list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)")
 
 # 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)
 
-# Look for the opm-tests repository; if found the variable
-# HAVE_OPM_TESTS will be set to true.
-include(Findopm-tests)
-
 # 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
@@ -63,50 +30,12 @@ include (${project}-prereqs)
 include (CMakeLists_files.cmake)
 
 macro (config_hook)
-  if(ENABLE_ECL_INPUT)
-    if(NOT cjson_FOUND)
-      list(APPEND EXTRA_INCLUDES ${PROJECT_SOURCE_DIR}/external/cjson)
-    endif()
-    # For this project
-    include_directories(${EXTRA_INCLUDES} ${PROJECT_BINARY_DIR}/include)
-
-    # For downstreams
-    list(APPEND EXTRA_INCLUDES ${PROJECT_BINARY_DIR}/include)
-    set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
-                                       list(APPEND opm-common_INCLUDE_DIRS ${EXTRA_INCLUDES})")
-    if(ENABLE_ECL_INPUT)
-      set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
-                                         set(HAVE_ECL_INPUT 1)")
-      set(OPM_PROJECT_EXTRA_CODE_INSTALLED "${OPM_PROJECT_EXTRA_CODE_INSTALLED}
-                                            set(HAVE_ECL_INPUT 1)")
-    endif()
-    if(ENABLE_ECL_OUTPUT)
-      set(OPM_PROJECT_EXTRA_CODE_INTREE "${OPM_PROJECT_EXTRA_CODE_INTREE}
-                                         set(HAVE_ECL_OUTPUT 1)")
-      set(OPM_PROJECT_EXTRA_CODE_INSTALLED "${OPM_PROJECT_EXTRA_CODE_INSTALLED}
-                                            set(HAVE_ECL_OUTPUT 1)")
-    endif()
-
-    # Configure boost targets for old cmake
-    include(cmake/Modules/BoostTargets.cmake)
-
-    if (HAVE_DYNAMIC_BOOST_TEST)
-      set_target_properties(Boost::unit_test_framework PROPERTIES INTERFACE_COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK=1)
-    endif()
-  endif()
 endmacro (config_hook)
 
 macro (prereqs_hook)
 endmacro (prereqs_hook)
 
 macro (sources_hook)
-  if(ENABLE_ECL_INPUT)
-    # Keyword generation
-    include(GenerateKeywords.cmake)
-
-    # Append generated sources
-    list(APPEND opm-common_SOURCES ${PROJECT_BINARY_DIR}/ParserKeywords.cpp)
-  endif()
 endmacro (sources_hook)
 
 macro (fortran_hook)
@@ -116,17 +45,8 @@ macro (files_hook)
 endmacro (files_hook)
 
 macro (tests_hook)
-  if(ENABLE_ECL_INPUT)
-    include(ExtraTests.cmake)
-  endif()
 endmacro (tests_hook)
 
-macro (install_hook)
-  install(DIRECTORY ${PROJECT_BINARY_DIR}/include/
-          DESTINATION include
-          PATTERN *.hpp)
-endmacro (install_hook)
-
 # all setup common to the OPM library modules is done here
 include (OpmLibMain)
 

CMakeLists_files.cmake

@@ -21,293 +21,42 @@
 #	                      the library needs it.
 
 list (APPEND MAIN_SOURCE_FILES
-      src/opm/common/data/SimulationDataContainer.cpp
-      src/opm/common/OpmLog/CounterLog.cpp
-      src/opm/common/OpmLog/EclipsePRTLog.cpp
-      src/opm/common/OpmLog/LogBackend.cpp
-      src/opm/common/OpmLog/Logger.cpp
-      src/opm/common/OpmLog/LogUtil.cpp
-      src/opm/common/OpmLog/OpmLog.cpp
-      src/opm/common/OpmLog/StreamLog.cpp
-      src/opm/common/OpmLog/TimerLog.cpp
-      src/opm/common/utility/numeric/MonotCubicInterpolator.cpp
-      src/opm/common/utility/parameters/Parameter.cpp
-      src/opm/common/utility/parameters/ParameterGroup.cpp
-      src/opm/common/utility/parameters/ParameterTools.cpp
-      src/opm/common/utility/numeric/calculateCellVol.cpp
+      opm/common/data/SimulationDataContainer.cpp
+      opm/common/OpmLog/CounterLog.cpp
+      opm/common/OpmLog/EclipsePRTLog.cpp
+      opm/common/OpmLog/LogBackend.cpp
+      opm/common/OpmLog/Logger.cpp
+      opm/common/OpmLog/LogUtil.cpp
+      opm/common/OpmLog/OpmLog.cpp
+      opm/common/OpmLog/StreamLog.cpp
+      opm/common/OpmLog/TimerLog.cpp
 )
-if(ENABLE_ECL_INPUT)
-  list(APPEND MAIN_SOURCE_FILES
-    src/opm/json/JsonObject.cpp
-    src/opm/parser/eclipse/Deck/Deck.cpp
-    src/opm/parser/eclipse/Deck/DeckItem.cpp
-    src/opm/parser/eclipse/Deck/DeckKeyword.cpp
-    src/opm/parser/eclipse/Deck/DeckRecord.cpp
-    src/opm/parser/eclipse/Deck/DeckOutput.cpp
-    src/opm/parser/eclipse/Deck/Section.cpp
-    src/opm/parser/eclipse/EclipseState/AquiferCT.cpp
-    src/opm/parser/eclipse/EclipseState/Aquancon.cpp
-    src/opm/parser/eclipse/EclipseState/checkDeck.cpp
-    src/opm/parser/eclipse/EclipseState/Eclipse3DProperties.cpp
-    src/opm/parser/eclipse/EclipseState/EclipseConfig.cpp
-    src/opm/parser/eclipse/EclipseState/EclipseState.cpp
-    src/opm/parser/eclipse/EclipseState/EndpointScaling.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/Box.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/BoxManager.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/FaceDir.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/FaultCollection.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/Fault.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/FaultFace.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/GridDims.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/GridProperties.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/GridProperty.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/NNC.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/PinchMode.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/SatfuncPropertyInitializers.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/setKeywordBox.cpp
-    src/opm/parser/eclipse/EclipseState/Grid/TransMult.cpp
-    src/opm/parser/eclipse/EclipseState/InitConfig/Equil.cpp
-    src/opm/parser/eclipse/EclipseState/InitConfig/InitConfig.cpp
-    src/opm/parser/eclipse/EclipseState/IOConfig/IOConfig.cpp
-    src/opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.cpp
-    src/opm/parser/eclipse/EclipseState/Runspec.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/Connection.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellConnections.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/Events.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/Group.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/GroupTree.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/MessageLimits.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/MSW/Compsegs.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/MSW/updatingConnectionsWithSegments.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/TimeMap.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/Tuning.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/Well.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellEconProductionLimits.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellTestConfig.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/WellTestState.cpp
-    src/opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.cpp
-    src/opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.cpp
-    src/opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/ColumnSchema.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/JFunc.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/PvtxTable.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/SimpleTable.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/TableColumn.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/TableContainer.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/TableIndex.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/TableManager.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/TableSchema.cpp
-    src/opm/parser/eclipse/EclipseState/Tables/Tables.cpp
-    src/opm/parser/eclipse/EclipseState/UDQConfig.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/UDQ.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/UDQExpression.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.cpp
-    src/opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.cpp
-    src/opm/parser/eclipse/Parser/ParseContext.cpp
-    src/opm/parser/eclipse/Parser/Parser.cpp
-    src/opm/parser/eclipse/Parser/ParserEnums.cpp
-    src/opm/parser/eclipse/Parser/ParserItem.cpp
-    src/opm/parser/eclipse/Parser/ParserKeyword.cpp
-    src/opm/parser/eclipse/Parser/ParserRecord.cpp
-    src/opm/parser/eclipse/RawDeck/RawKeyword.cpp
-    src/opm/parser/eclipse/RawDeck/RawRecord.cpp
-    src/opm/parser/eclipse/RawDeck/StarToken.cpp
-    src/opm/parser/eclipse/Units/Dimension.cpp
-    src/opm/parser/eclipse/Units/UnitSystem.cpp
-    src/opm/parser/eclipse/Utility/Functional.cpp
-    src/opm/parser/eclipse/Utility/Stringview.cpp
-  )
-
-  if(NOT cjson_FOUND)
-    list(APPEND MAIN_SOURCE_FILES external/cjson/cJSON.c)
-  endif()
-endif()
-if(ENABLE_ECL_OUTPUT)
-  list( APPEND MAIN_SOURCE_FILES
-          src/opm/test_util/summaryIntegrationTest.cpp
-          src/opm/test_util/summaryRegressionTest.cpp
-          src/opm/test_util/summaryComparator.cpp
-          src/opm/test_util/EclFilesComparator.cpp
-          src/opm/output/eclipse/AggregateWellData.cpp
-          src/opm/output/eclipse/CreateDoubHead.cpp
-          src/opm/output/eclipse/CreateInteHead.cpp
-          src/opm/output/eclipse/CreateLogiHead.cpp
-          src/opm/output/eclipse/WellDataSerializers.cpp
-          src/opm/output/eclipse/DoubHEAD.cpp
-          src/opm/output/eclipse/EclipseGridInspector.cpp
-          src/opm/output/eclipse/EclipseIO.cpp
-          src/opm/output/eclipse/InteHEAD.cpp
-          src/opm/output/eclipse/LinearisedOutputTable.cpp
-          src/opm/output/eclipse/LogiHEAD.cpp
-          src/opm/output/eclipse/RestartIO.cpp
-          src/opm/output/eclipse/Summary.cpp
-          src/opm/output/eclipse/SummaryState.cpp
-          src/opm/output/eclipse/Tables.cpp
-          src/opm/output/eclipse/RegionCache.cpp
-          src/opm/output/eclipse/RestartValue.cpp
-          src/opm/output/data/Solution.cpp
-      )
-endif()
 
 list (APPEND TEST_SOURCE_FILES
-      tests/test_calculateCellVol.cpp
-      tests/test_cmp.cpp
-      tests/test_cubic.cpp
-      tests/test_messagelimiter.cpp
-      tests/test_nonuniformtablelinear.cpp
-      tests/test_OpmLog.cpp
-      tests/test_param.cpp
       tests/test_SimulationDataContainer.cpp
-      tests/test_sparsevector.cpp
-      tests/test_uniformtablelinear.cpp
-)
-if(ENABLE_ECL_INPUT)
-  list(APPEND TEST_SOURCE_FILES
-    tests/parser/ADDREGTests.cpp
-    tests/parser/AquiferCTTests.cpp
-    tests/parser/AqudimsTests.cpp
-    tests/parser/AquanconTests.cpp
-    tests/parser/BoxTests.cpp
-    tests/parser/ColumnSchemaTests.cpp
-    tests/parser/ConnectionTests.cpp
-    tests/parser/COMPSEGUnits.cpp
-    tests/parser/CopyRegTests.cpp
-    tests/parser/DeckTests.cpp
-    tests/parser/DynamicStateTests.cpp
-    tests/parser/DynamicVectorTests.cpp
-    tests/parser/Eclipse3DPropertiesTests.cpp
-    tests/parser/EclipseGridTests.cpp
-    tests/parser/EqualRegTests.cpp
-    tests/parser/EventTests.cpp
-    tests/parser/FaceDirTests.cpp
-    tests/parser/FaultTests.cpp
-    tests/parser/FunctionalTests.cpp
-    tests/parser/GeomodifierTests.cpp
-    tests/parser/GridPropertyTests.cpp
-    tests/parser/GroupTests.cpp
-    tests/parser/InitConfigTest.cpp
-    tests/parser/IOConfigTests.cpp
-    tests/parser/MessageLimitTests.cpp
-    tests/parser/MultiRegTests.cpp
-    tests/parser/MultisegmentWellTests.cpp
-    tests/parser/MULTREGTScannerTests.cpp
-    tests/parser/OrderedMapTests.cpp
-    tests/parser/ParseContextTests.cpp
-    tests/parser/PORVTests.cpp
-    tests/parser/RawKeywordTests.cpp
-    tests/parser/RestartConfigTests.cpp
-    tests/parser/RunspecTests.cpp
-    tests/parser/SatfuncPropertyInitializersTests.cpp
-    tests/parser/ScheduleTests.cpp
-    tests/parser/SectionTests.cpp
-    tests/parser/SimpleTableTests.cpp
-    tests/parser/SimulationConfigTest.cpp
-    tests/parser/StarTokenTests.cpp
-    tests/parser/StringTests.cpp
-    tests/parser/SummaryConfigTests.cpp
-    tests/parser/TabdimsTests.cpp
-    tests/parser/TableColumnTests.cpp
-    tests/parser/TableContainerTests.cpp
-    tests/parser/TableManagerTests.cpp
-    tests/parser/TableSchemaTests.cpp
-    tests/parser/ThresholdPressureTest.cpp
-    tests/parser/TimeMapTest.cpp
-    tests/parser/TransMultTests.cpp
-    tests/parser/TuningTests.cpp
-    tests/parser/UDQTests.cpp
-    tests/parser/UnitTests.cpp
-    tests/parser/ValueTests.cpp
-    tests/parser/WellSolventTests.cpp
-    tests/parser/WellTests.cpp
-    tests/parser/WTEST.cpp)
-endif()
-if(ENABLE_ECL_OUTPUT)
-  list (APPEND TEST_SOURCE_FILES
-          tests/test_AggregateWellData.cpp
-          tests/test_CharArrayNullTerm.cpp
-          tests/test_compareSummary.cpp
-          tests/test_EclFilesComparator.cpp
-          tests/test_EclipseIO.cpp
-          tests/test_DoubHEAD.cpp
-          tests/test_InteHEAD.cpp
-          tests/test_LinearisedOutputTable.cpp
-          tests/test_LogiHEAD.cpp
-          tests/test_regionCache.cpp
-          tests/test_Restart.cpp
-          tests/test_RFT.cpp
-          tests/test_Solution.cpp
-          tests/test_Summary.cpp
-          tests/test_Tables.cpp
-          tests/test_Wells.cpp
-          tests/test_WindowedArray.cpp
-          tests/test_writenumwells.cpp
-          tests/test_serialize_ICON.cpp
-          tests/test_serialize_SCON.cpp
+      tests/test_cmp.cpp
+      tests/test_OpmLog.cpp
+      tests/test_messagelimiter.cpp
       )
-endif()
 
 list (APPEND TEST_DATA_FILES
-      tests/testdata.param
-)
-if(ENABLE_ECL_OUTPUT)
-  list (APPEND TEST_DATA_FILES
-          tests/FIRST_SIM.DATA
-          tests/FIRST_SIM_THPRES.DATA
-          tests/summary_deck.DATA
-          tests/group_group.DATA
-          tests/testblackoilstate3.DATA
-          tests/testrft.DATA
-          tests/table_deck.DATA
-          tests/summary_deck_non_constant_porosity.DATA
-          tests/SUMMARY_EFF_FAC.DATA
-      )
-endif()
+	)
 
 list (APPEND EXAMPLE_SOURCE_FILES
-)
-if(ENABLE_ECL_INPUT)
-  list (APPEND EXAMPLE_SOURCE_FILES
-    examples/opmi.cpp
-    examples/opmpack.cpp
-  )
-endif()
-if(ENABLE_ECL_OUTPUT)
-  list(APPEND EXAMPLE_SOURCE_FILES
-          examples/test_util/compareECL.cpp
-          examples/test_util/compareSummary.cpp
-      )
-endif()
+	)
 
 # programs listed here will not only be compiled, but also marked for
 # installation
 list (APPEND PROGRAM_SOURCE_FILES
-)
-if(ENABLE_ECL_INPUT)
-  list (APPEND PROGRAM_SOURCE_FILES
-    examples/opmi.cpp
-    examples/opmpack.cpp
-  )
-endif()
-if(ENABLE_ECL_OUTPUT)
-  list(APPEND PROGRAM_SOURCE_FILES
-          examples/test_util/compareECL.cpp
-          examples/test_util/compareSummary.cpp
-      )
-endif()
+	)
+
 
 list( APPEND PUBLIC_HEADER_FILES
       opm/common/ErrorMacros.hpp
       opm/common/Exceptions.hpp
+      opm/common/ResetLocale.hpp
+      opm/common/Unused.hpp
+      opm/common/Valgrind.hpp
       opm/common/data/SimulationDataContainer.hpp
       opm/common/OpmLog/CounterLog.hpp
       opm/common/OpmLog/EclipsePRTLog.hpp
@@ -319,204 +68,6 @@ list( APPEND PUBLIC_HEADER_FILES
       opm/common/OpmLog/OpmLog.hpp
       opm/common/OpmLog/StreamLog.hpp
       opm/common/OpmLog/TimerLog.hpp
-      opm/common/utility/numeric/cmp.hpp
+      opm/common/util/numeric/cmp.hpp
       opm/common/utility/platform_dependent/disable_warnings.h
-      opm/common/utility/platform_dependent/reenable_warnings.h
-      opm/common/utility/numeric/blas_lapack.h
-      opm/common/utility/numeric/buildUniformMonotoneTable.hpp
-      opm/common/utility/numeric/linearInterpolation.hpp
-      opm/common/utility/numeric/MonotCubicInterpolator.hpp
-      opm/common/utility/numeric/NonuniformTableLinear.hpp
-      opm/common/utility/numeric/RootFinders.hpp
-      opm/common/utility/numeric/SparseVector.hpp
-      opm/common/utility/numeric/UniformTableLinear.hpp
-      opm/common/utility/parameters/ParameterGroup.hpp
-      opm/common/utility/parameters/ParameterGroup_impl.hpp
-      opm/common/utility/parameters/Parameter.hpp
-      opm/common/utility/parameters/ParameterMapItem.hpp
-      opm/common/utility/parameters/ParameterRequirement.hpp
-      opm/common/utility/parameters/ParameterStrings.hpp
-      opm/common/utility/parameters/ParameterTools.hpp
-      opm/common/utility/numeric/calculateCellVol.hpp
-)
-if(ENABLE_ECL_INPUT)
-  list(APPEND PUBLIC_HEADER_FILES
-       opm/json/JsonObject.hpp
-       opm/parser/eclipse/Utility/Stringview.hpp
-       opm/parser/eclipse/Utility/Functional.hpp
-       opm/parser/eclipse/Utility/Typetools.hpp
-       opm/parser/eclipse/Utility/String.hpp
-       opm/parser/eclipse/Generator/KeywordGenerator.hpp
-       opm/parser/eclipse/Generator/KeywordLoader.hpp
-       opm/parser/eclipse/Units/UnitSystem.hpp
-       opm/parser/eclipse/Units/Units.hpp
-       opm/parser/eclipse/Units/Dimension.hpp
-       opm/parser/eclipse/Parser/ParserItem.hpp
-       opm/parser/eclipse/Parser/Parser.hpp
-       opm/parser/eclipse/Parser/ParserRecord.hpp
-       opm/parser/eclipse/Parser/ParserKeyword.hpp
-       opm/parser/eclipse/Parser/InputErrorAction.hpp
-       opm/parser/eclipse/Parser/ParserEnums.hpp
-       opm/parser/eclipse/Parser/ParseContext.hpp
-       opm/parser/eclipse/Parser/ParserConst.hpp
-       opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp
-       opm/parser/eclipse/EclipseState/InitConfig/Equil.hpp
-       opm/parser/eclipse/EclipseState/Util/Value.hpp
-       opm/parser/eclipse/EclipseState/Util/OrderedMap.hpp
-       opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp
-       opm/parser/eclipse/EclipseState/Grid/GridDims.hpp
-       opm/parser/eclipse/EclipseState/Grid/TransMult.hpp
-       opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp
-       opm/parser/eclipse/EclipseState/Grid/PinchMode.hpp
-       opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp
-       opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp
-       opm/parser/eclipse/EclipseState/Grid/SatfuncPropertyInitializers.hpp
-       opm/parser/eclipse/EclipseState/Grid/Fault.hpp
-       opm/parser/eclipse/EclipseState/Grid/Box.hpp
-       opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp
-       opm/parser/eclipse/EclipseState/Grid/FaultFace.hpp
-       opm/parser/eclipse/EclipseState/Grid/NNC.hpp
-       opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
-       opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp
-       opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp
-       opm/parser/eclipse/EclipseState/Grid/MinpvMode.hpp
-       opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp
-       opm/parser/eclipse/EclipseState/EndpointScaling.hpp
-       opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PdvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/TlpmixpaTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PvdgTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/MsfnTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/GasvisctTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/Regdims.hpp
-       opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp
-       opm/parser/eclipse/EclipseState/Tables/SpecrockTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PlydhflfTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/RsvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SpecheatTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SgcwmisTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/Sof2Table.hpp
-       opm/parser/eclipse/EclipseState/Tables/TableManager.hpp
-       opm/parser/eclipse/EclipseState/Tables/SwfnTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/EnptvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SwofTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/FlatTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/Aqudims.hpp
-       opm/parser/eclipse/EclipseState/Tables/JFunc.hpp
-       opm/parser/eclipse/EclipseState/Tables/TableIndex.hpp
-       opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/Tabdims.hpp
-       opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp
-       opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/EnkrvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PlyrockTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/WatvisctTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/TableEnums.hpp
-       opm/parser/eclipse/EclipseState/Tables/RvvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp
-       opm/parser/eclipse/EclipseState/Tables/AqutabTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PlyadsTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PbvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SorwmisTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PlymaxTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PlyviscTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/TableColumn.hpp
-       opm/parser/eclipse/EclipseState/Tables/SsfnTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PvdoTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/OilvisctTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SgfnTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/MiscTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SgwfnTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PvdsTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp
-       opm/parser/eclipse/EclipseState/Tables/PmiscTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/RtempvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/SlgofTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/ImptvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/ImkrvdTable.hpp
-       opm/parser/eclipse/EclipseState/Tables/Sof3Table.hpp
-       opm/parser/eclipse/EclipseState/Tables/SgofTable.hpp
-       opm/parser/eclipse/EclipseState/EclipseState.hpp
-       opm/parser/eclipse/EclipseState/EclipseConfig.hpp
-       opm/parser/eclipse/EclipseState/Aquancon.hpp
-       opm/parser/eclipse/EclipseState/AquiferCT.hpp
-       opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp
-       opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp
-       opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp
-       opm/parser/eclipse/EclipseState/Schedule/Well.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp
-       opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp
-       opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellEconProductionLimits.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.hpp
-       opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp
-       opm/parser/eclipse/EclipseState/Schedule/Group.hpp
-       opm/parser/eclipse/EclipseState/Schedule/MessageLimits.hpp
-       opm/parser/eclipse/EclipseState/Schedule/Events.hpp
-       opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp
-       opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp
-       opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp
-       opm/parser/eclipse/EclipseState/Schedule/Connection.hpp
-       opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp
-       opm/parser/eclipse/EclipseState/Schedule/MSW/Segment.hpp
-       opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp
-       opm/parser/eclipse/EclipseState/Schedule/MSW/updatingConnectionsWithSegments.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellTestConfig.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellTestState.hpp
-       opm/parser/eclipse/EclipseState/Schedule/WellConnections.hpp
-       opm/parser/eclipse/EclipseState/SimulationConfig/ThresholdPressure.hpp
-       opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp
-       opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.hpp
-       opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp
-       opm/parser/eclipse/EclipseState/checkDeck.hpp
-       opm/parser/eclipse/EclipseState/Runspec.hpp
-       opm/parser/eclipse/EclipseState/Schedule/UDQ.hpp
-       opm/parser/eclipse/EclipseState/UDQConfig.hpp
-       opm/parser/eclipse/EclipseState/Schedule/UDQExpression.hpp
-       opm/parser/eclipse/Deck/DeckItem.hpp
-       opm/parser/eclipse/Deck/Deck.hpp
-       opm/parser/eclipse/Deck/Section.hpp
-       opm/parser/eclipse/Deck/DeckOutput.hpp
-       opm/parser/eclipse/Deck/DeckKeyword.hpp
-       opm/parser/eclipse/Deck/DeckRecord.hpp
-       opm/parser/eclipse/RawDeck/StarToken.hpp
-       opm/parser/eclipse/RawDeck/RawEnums.hpp
-       opm/parser/eclipse/RawDeck/RawRecord.hpp
-       opm/parser/eclipse/RawDeck/RawKeyword.hpp
-       opm/parser/eclipse/RawDeck/RawConsts.hpp)
-endif()
-if(ENABLE_ECL_OUTPUT)
-  list(APPEND PUBLIC_HEADER_FILES
-        opm/output/data/Cells.hpp
-        opm/output/data/Solution.hpp
-        opm/output/data/Wells.hpp
-        opm/output/eclipse/VectorItems/intehead.hpp
-        opm/output/eclipse/VectorItems/well.hpp
-        opm/output/eclipse/AggregateWellData.hpp
-        opm/output/eclipse/CharArrayNullTerm.hpp
-        opm/output/eclipse/DoubHEAD.hpp
-        opm/output/eclipse/EclipseGridInspector.hpp
-        opm/output/eclipse/EclipseIO.hpp
-        opm/output/eclipse/EclipseIOUtil.hpp
-        opm/output/eclipse/InteHEAD.hpp
-        opm/output/eclipse/LogiHEAD.hpp
-        opm/output/eclipse/LinearisedOutputTable.hpp
-        opm/output/eclipse/RegionCache.hpp
-        opm/output/eclipse/RestartIO.hpp
-        opm/output/eclipse/RestartValue.hpp
-        opm/output/eclipse/Summary.hpp
-        opm/output/eclipse/SummaryState.hpp
-        opm/output/eclipse/Tables.hpp
-        opm/output/eclipse/WindowedArray.hpp
-        opm/output/eclipse/WriteRestartHelpers.hpp
-        opm/output/OutputWriter.hpp
-        opm/test_util/EclFilesComparator.hpp
-        opm/test_util/summaryComparator.hpp
-        opm/test_util/summaryIntegrationTest.hpp
-        opm/test_util/summaryRegressionTest.hpp
-        )
-endif()
+      opm/common/utility/platform_dependent/reenable_warnings.h)

CopyHeaders.cmake

@@ -1,21 +0,0 @@
-execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                        ${BASE_DIR}/tmp_gen/ParserKeywords.cpp
-                        ${BASE_DIR}/ParserKeywords.cpp)
-
-execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                        ${BASE_DIR}/tmp_gen/inlinekw.cpp
-                        ${BASE_DIR}/inlinekw.cpp)
-
-execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                        ${BASE_DIR}/tmp_gen/include/opm/parser/eclipse/Parser/ParserKeywords.hpp
-                        ${BASE_DIR}/include/opm/parser/eclipse/Parser/ParserKeywords.hpp)
-
-
-file(GLOB HDRS ${BASE_DIR}/tmp_gen/include/opm/parser/eclipse/Parser/ParserKeywords/*.hpp)
-
-foreach(HDR ${HDRS})
-  file(RELATIVE_PATH hdr ${BASE_DIR}/tmp_gen/include/opm/parser/eclipse/Parser/ParserKeywords ${HDR})
-  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                          ${HDR}
-                          ${BASE_DIR}/include/opm/parser/eclipse/Parser/ParserKeywords/${hdr})
-endforeach()

ExtraTests.cmake

@@ -1,107 +0,0 @@
-# Libs to link tests against
-set(TEST_LIBS opmcommon ecl Boost::unit_test_framework)
-set(EXTRA_TESTS)
-
-# Generated source, needs to be here
-opm_add_test(InlineKeywordTest
-             EXE_NAME inlinekw
-             SOURCES ${PROJECT_BINARY_DIR}/inlinekw.cpp
-             LIBRARIES ${TEST_LIBS})
-list(APPEND EXTRA_TESTS inlinekw)
-
-# Extra compile definitions and extra parameters
-include(cmake/Modules/CheckCaseSensitiveFileSystem.cmake)
-set(_testdir ${PROJECT_SOURCE_DIR}/tests/parser/data)
-
-opm_add_test(LoaderTest
-             SOURCES tests/parser/KeywordLoaderTests.cpp
-                     src/opm/parser/eclipse/Generator/KeywordLoader.cpp
-             LIBRARIES ${TEST_LIBS}
-             TEST_ARGS ${_testdir}/parser/keyword-generator/)
-list(APPEND EXTRA_TESTS LoaderTest)
-
-opm_add_test(ParserTests
-             SOURCES tests/parser/ParserTests.cpp
-             LIBRARIES ${TEST_LIBS}
-             TEST_ARGS ${_testdir}/)
-list(APPEND EXTRA_TESTS ParserTests)
-
-opm_add_test(ParserIncludeTests
-             SOURCES tests/parser/ParserIncludeTests.cpp
-             LIBRARIES ${TEST_LIBS}
-             TEST_ARGS ${_testdir}/parser/)
-target_compile_definitions(ParserIncludeTests PRIVATE
-                           -DHAVE_CASE_SENSITIVE_FILESYSTEM=${HAVE_CASE_SENSITIVE_FILESYSTEM})
-list(APPEND EXTRA_TESTS ParserIncludeTests)
-
-opm_add_test(PvtxTableTests
-             SOURCES tests/parser/PvtxTableTests.cpp
-             LIBRARIES ${TEST_LIBS}
-             TEST_ARGS ${_testdir}/integration_tests/)
-list(APPEND EXTRA_TESTS PvtxTableTests)
-
-opm_add_test(EclipseStateTests
-             SOURCES tests/parser/EclipseStateTests.cpp
-             LIBRARIES ${TEST_LIBS}
-             TEST_ARGS ${_testdir}/integration_tests/)
-list(APPEND EXTRA_TESTS EclipseStateTests)
-
-foreach (test BoxTest
-              CheckDeckValidity
-              EclipseGridCreateFromDeck
-              IncludeTest
-              IntegrationTests
-              IOConfigIntegrationTest
-              NNCTests
-              ParseKEYWORD
-              ParseDATAWithDefault
-              Polymer
-              ResinsightTest
-              ScheduleCreateFromDeck
-              TransMultIntegrationTests)
-
-  opm_add_test(${test}
-               SOURCES tests/parser/integration/${test}.cpp
-               LIBRARIES ${TEST_LIBS}
-               TEST_ARGS ${_testdir}/integration_tests/)
-  list(APPEND EXTRA_TESTS ${test})
-endforeach ()
-
-# opm-tests dependent tests
-if(HAVE_OPM_TESTS)
-  opm_add_test(parse_write ONLY_COMPILE
-               SOURCES tests/parser/integration/parse_write.cpp
-               LIBRARIES ${TEST_LIBS})
-  list(APPEND EXTRA_TESTS parse_write)
-  foreach (deck ${OPM_TESTS_ROOT}/norne/NORNE_ATW2013.DATA
-                ${OPM_TESTS_ROOT}/spe1_solvent/SPE1CASE2_SOLVENT.DATA
-                ${OPM_TESTS_ROOT}/spe9_solvent/SPE9_CP_SOLVENT_CO2.DATA
-                ${OPM_TESTS_ROOT}/spe5/SPE5CASE1.DATA
-                ${OPM_TESTS_ROOT}/polymer_simple2D/2D_THREEPHASE_POLY_HETER.DATA
-                ${OPM_TESTS_ROOT}/spe1/SPE1CASE1.DATA
-                ${OPM_TESTS_ROOT}/spe1/SPE1CASE2.DATA
-                ${OPM_TESTS_ROOT}/spe1/SPE1CASE2_FAMII.DATA
-                ${OPM_TESTS_ROOT}/spe1/SPE1CASE2_SLGOF.DATA
-                ${OPM_TESTS_ROOT}/spe3/SPE3CASE1.DATA
-                ${OPM_TESTS_ROOT}/spe3/SPE3CASE2.DATA
-                ${OPM_TESTS_ROOT}/spe9/SPE9_CP.DATA
-                ${OPM_TESTS_ROOT}/spe9/SPE9_CP_GROUP.DATA
-                ${OPM_TESTS_ROOT}/spe9/SPE9.DATA
-                ${OPM_TESTS_ROOT}/spe10model1/SPE10_MODEL1.DATA
-                ${OPM_TESTS_ROOT}/spe10model2/SPE10_MODEL2.DATA
-                ${OPM_TESTS_ROOT}/msw_2d_h/2D_H__.DATA )
-      get_filename_component(test_name ${deck} NAME_WE)
-      opm_add_test(${test_name} NO_COMPILE
-                   EXE_NAME parse_write
-                   TEST_ARGS ${deck})
-  endforeach()
-  set_property(TEST NORNE_ATW2013
-               PROPERTY ENVIRONMENT "OPM_ERRORS_IGNORE=PARSE_RANDOM_SLASH")
-endif()
-
-# JSON tests
-opm_add_test(jsonTests
-             SOURCES tests/json/jsonTests.cpp
-             LIBRARIES ${TEST_LIBS}
-             TEST_ARGS ${PROJECT_SOURCE_DIR}/tests/json/example1.json)
-list(APPEND EXTRA_TESTS jsonTests)

GenerateKeywords.cmake

@@ -1,54 +0,0 @@
-set(genkw_SOURCES src/opm/json/JsonObject.cpp
-                  src/opm/parser/eclipse/Parser/createDefaultKeywordList.cpp
-                  src/opm/parser/eclipse/Deck/Deck.cpp
-                  src/opm/parser/eclipse/Deck/DeckItem.cpp
-                  src/opm/parser/eclipse/Deck/DeckKeyword.cpp
-                  src/opm/parser/eclipse/Deck/DeckRecord.cpp
-                  src/opm/parser/eclipse/Deck/DeckOutput.cpp
-                  src/opm/parser/eclipse/Generator/KeywordGenerator.cpp
-                  src/opm/parser/eclipse/Generator/KeywordLoader.cpp
-                  src/opm/parser/eclipse/Parser/ParseContext.cpp
-                  src/opm/parser/eclipse/Parser/ParserEnums.cpp
-                  src/opm/parser/eclipse/Parser/ParserItem.cpp
-                  src/opm/parser/eclipse/Parser/ParserKeyword.cpp
-                  src/opm/parser/eclipse/Parser/ParserRecord.cpp
-                  src/opm/parser/eclipse/RawDeck/RawKeyword.cpp
-                  src/opm/parser/eclipse/RawDeck/RawRecord.cpp
-                  src/opm/parser/eclipse/RawDeck/StarToken.cpp
-                  src/opm/parser/eclipse/Units/Dimension.cpp
-                  src/opm/parser/eclipse/Units/UnitSystem.cpp
-                  src/opm/parser/eclipse/Utility/Stringview.cpp
-                  src/opm/common/OpmLog/OpmLog.cpp
-                  src/opm/common/OpmLog/Logger.cpp
-                  src/opm/common/OpmLog/StreamLog.cpp
-                  src/opm/common/OpmLog/LogBackend.cpp
-                  src/opm/common/OpmLog/LogUtil.cpp
-)
-if(NOT cjson_FOUND)
-  list(APPEND genkw_SOURCES external/cjson/cJSON.c)
-endif()
-add_executable(genkw ${genkw_SOURCES})
-
-target_link_libraries(genkw ecl Boost::regex Boost::filesystem Boost::system)
-
-# Generate keyword list
-include(src/opm/parser/eclipse/share/keywords/keyword_list.cmake)
-string(REGEX REPLACE "([^;]+)" "${PROJECT_SOURCE_DIR}/src/opm/parser/eclipse/share/keywords/\\1" keyword_files "${keywords}")
-configure_file(src/opm/parser/eclipse/keyword_list.argv.in keyword_list.argv)
-
-# Generate keyword source
-add_custom_command(
-    OUTPUT  ${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords.cpp ${PROJECT_BINARY_DIR}/tmp_gen/inlinekw.cpp
-    COMMAND genkw keyword_list.argv
-                  ${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords.cpp
-                  ${PROJECT_BINARY_DIR}/tmp_gen/include/
-                  opm/parser/eclipse/Parser/ParserKeywords
-                  ${PROJECT_BINARY_DIR}/tmp_gen/inlinekw.cpp
-    DEPENDS genkw ${keyword_files} src/opm/parser/eclipse/share/keywords/keyword_list.cmake
-)
-
-# To avoid some rebuilds
-add_custom_command(OUTPUT ParserKeywords.cpp inlinekw.cpp
-                   DEPENDS ${PROJECT_BINARY_DIR}/tmp_gen/ParserKeywords.cpp
-                   COMMAND ${CMAKE_COMMAND} -DBASE_DIR=${PROJECT_BINARY_DIR}
-                                            -P ${PROJECT_SOURCE_DIR}/CopyHeaders.cmake)

README.md

@@ -1,3 +1,3 @@
-# opm-common
+# opm-common ![alt text](https://travis-ci.org/OPM/opm-common.svg?branch=master "TravisCI Build Status")
 Contains common components used throughout all of OPM,
 in particular CMake modules for the build system.

changelog.md

@@ -1,45 +0,0 @@
-# Changelog
-
-A short month-by-month synopsis of change highlights. Most bugfixes won't make
-it in here, only the bigger features and interface changes.
-
-# 2016.12
-* ZCORN adjustments improved, considers cell-cell relations
-* Slightly more robust compilation - won't crash if locales are broken
-* Accessing the PVTW table has a richer interface
-* FAULTS face direction accepts X+, I+, Y+, J+, Z+ and K+
-* WELOPEN can be controlled with completion numbers (last two parameters)
-* COMPLUMP is now supported
-* Don't crash on aquifer keywords
-* GMWSET and FMWSET are expanded properly
-* Don't crash on DEBUG
-* Read support for COORDSYS, GRUPRIG, LGR, PRORDER, TRACERS, TUNINGDP,
-  WDFACCOR, WEFAC, and WORKLIM, no longer crashes.
-* RS and RV support.
-* Support for DENSITY, PVTW, and ROCK tables
-* JFUNC is understood and exposed
-
-# 2016.11
-* A new class, Runspec, for the RUNSPEC section, has been introduced
-* Nodes in the FIELD group are no longer added to the Summary config
-* WCONHIST only adds phases present in the deck
-* cJSON can now be installed externally
-* DeckItem and ParserItem internals refactored
-* Build time reduced by only giving necessary source files to the json compiler
-* Support for OPERATE, WSEGITER and GCONPROD
-* Internal shared_ptrs removed from Schedule and children; interface updated
-* Schedule is now copyable with regular C++ copy semantics - no internal refs
-* Well head I/J is now time step dependent
-* Well reference depth is time step dependent
-* Some ZCORN issues fixed
-* gas/oil and oil/gas ratio unit fixed for FIELD units
-
-# 2016.10
-* Significant improvements in overall parser performance
-* shared_ptr has largely been removed from all public interfaces
-* JFUNC keyword can be parsed
-* Boolean conversions are explicit
-* The Units.hpp header from core is moved here, replacing ConversionFactors
-* The ConstPtr and Ptr shared pointer aliases are removed
-* UnitSystem, Eclipse3DProperties, and OilVaporizationProperties are default
-  constructible

cmake/Modules/BoostTargets.cmake

@@ -1,49 +0,0 @@
-# make targets for boost if find module did not do the job
-
-if(NOT TARGET Boost::system)
-  add_library(Boost::system UNKNOWN IMPORTED)
-  set_target_properties(Boost::system PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      IMPORTED_LOCATION         "${Boost_SYSTEM_LIBRARY}"
-      IMPORTED_LOCATION_DEBUG   "${Boost_SYSTEM_LIBRARY_DEBUG}"
-      IMPORTED_LOCATION_RELEASE "${Boost_SYSTEM_LIBRARY_RELEASE}"
-  )
-endif()
-
-if(NOT TARGET Boost::filesystem)
-  add_library(Boost::filesystem UNKNOWN IMPORTED)
-  set_target_properties(Boost::filesystem PROPERTIES
-     INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_COMPILE_DEFINITIONS BOOST_FILESYSTEM_VERSION=3
-      INTERFACE_LINK_LIBRARIES  "${boost_system}"
-      IMPORTED_LOCATION         "${Boost_FILESYSTEM_LIBRARY}"
-      IMPORTED_LOCATION_DEBUG   "${Boost_FILESYSTEM_LIBRARY_DEBUG}"
-      IMPORTED_LOCATION_RELEASE "${Boost_FILESYSTEM_LIBRARY_RELEASE}"
-  )
-endif()
-
-if(NOT TARGET Boost::regex)
-  add_library(Boost::regex UNKNOWN IMPORTED)
-  set_target_properties(Boost::regex PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_LINK_LIBRARIES  "${boost_system}"
-      IMPORTED_LOCATION         "${Boost_REGEX_LIBRARY}"
-      IMPORTED_LOCATION_DEBUG   "${Boost_REGEX_LIBRARY_DEBUG}"
-      IMPORTED_LOCATION_RELEASE "${Boost_REGEX_LIBRARY_RELEASE}"
-  )
-endif()
-
-if(NOT TARGET Boost::unit_test_framework)
-  add_library(Boost::unit_test_framework UNKNOWN IMPORTED)
-  set_target_properties(Boost::unit_test_framework PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}"
-      INTERFACE_LINK_LIBRARIES  "${boost_system}"
-      IMPORTED_LOCATION         "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}"
-      IMPORTED_LOCATION_DEBUG   "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_DEBUG}"
-      IMPORTED_LOCATION_RELEASE "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY_RELEASE}"
-  )
-endif()

cmake/Modules/CheckCaseSensitiveFileSystem.cmake

@@ -1,29 +0,0 @@
-#
-# Module to check whether the file system is case sensitive or not
-#
-# Sets the following variable:
-#
-# HAVE_CASE_SENSITIVE_FILESYSTEM   True if the file system honors the case of files
-
-message(STATUS "Checking whether the file system is case-sensitive")
-# create a file containing uppercase characters
-file(WRITE "${CMAKE_BINARY_DIR}/UPPER" "Foo")
-
-# check if the all-lowercase file with the same name can be opened
-set(FooContents "")
-if (EXISTS "${CMAKE_BINARY_DIR}/upper")
-    file(READ "${CMAKE_BINARY_DIR}/upper" FooContents)
-endif()
-
-# remove the file again in order not to have it dangling around...
-file(REMOVE "${CMAKE_BINARY_DIR}/UPPER")
-
-# check the contents of the file opened with lower-case. If it is
-# empty, the file system is case sensitive.
-if ("${FooContents}" STREQUAL "Foo")
-  message(STATUS "File system is not case-sensitive")
-  set(HAVE_CASE_SENSITIVE_FILESYSTEM 0)
-else()
-  message(STATUS "File system is case-sensitive")
-  set(HAVE_CASE_SENSITIVE_FILESYSTEM 1)
-endif()

cmake/Modules/DuneCompat.cmake

@@ -0,0 +1,47 @@
+# - Dunecontrol compatibility
+#
+# Enables this build to be a part of a dunecontrol chain. The
+# DUNE_CHECK_MODULES macro greps the top-level Makefile for the
+# presence of the abs_top_srcdir variable (!) and uses that as
+# the include directory of a module. Also, the contents are not
+# checked so if the variable is not present, it generates an
+# invalid command line (-I without argument) which causes the
+# autoconf probe to fail. This module patches our Makefile (!!)
+# so the necessary string will be there; in itself this string
+# has no use for us, it is solemnly to satisfy the M4 scripts.
+
+if (CMAKE_GENERATOR MATCHES "Unix Makefiles")
+  # we need an up-to-date, patched Makefile. this is always checked when
+  # the makefile is run, thus the need for a marker file to keep a
+  # timestamp to see when it was last patched (by us)
+  # amazingly, nothing depends on the generated Makefile, so this can be
+  # run whenever in the build without trigging a compile of e.g. config.h
+  add_custom_target (dune-compat ALL
+	COMMAND ${CMAKE_COMMAND} -DCMAKE_HOME_DIRECTORY=${CMAKE_HOME_DIRECTORY} -P ${OPM_MACROS_ROOT}/cmake/Scripts/DuneCompat2.cmake
+	COMMENT "Patching Makefile to be DUNE compatible"
+	)
+endif (CMAKE_GENERATOR MATCHES "Unix Makefiles")
+
+# dunecontrol refuses to use a build tree as module directory unless
+# there is a dune.module in it. however, if we are in a sub-dir. of
+# the source, we are probably using dunecontrol with a --build-dir
+# argument, and won't call dunecontrol from the parent (which is the
+# source dir and most likely doesn't contain other projects) anyway,
+# i.e. we only copy if we are truly out-of-source
+string (LENGTH "${PROJECT_SOURCE_DIR}/" _src_dir_len)
+string (LENGTH "${PROJECT_BINARY_DIR}/" _bin_dir_len)
+if (_src_dir_len GREATER _bin_dir_len)
+  set (_not_substring TRUE)
+else (_src_dir_len GREATER _bin_dir_len)
+  string (SUBSTRING "${PROJECT_BINARY_DIR}/" 0 ${_src_dir_len} _proj_prefix)
+  if ("${PROJECT_SOURCE_DIR}/" STREQUAL "${_proj_prefix}")
+	set (_not_substring FALSE)
+  else ("${PROJECT_SOURCE_DIR}/" STREQUAL "${_proj_prefix}")
+	set (_not_substring TRUE)
+  endif ("${PROJECT_SOURCE_DIR}/" STREQUAL "${_proj_prefix}")
+endif (_src_dir_len GREATER _bin_dir_len)
+if (_not_substring)
+  execute_process (COMMAND
+	${CMAKE_COMMAND} -E copy_if_different ${PROJECT_SOURCE_DIR}/dune.module ${PROJECT_BINARY_DIR}/dune.module
+	)
+endif (_not_substring)

cmake/Modules/FindSuperLU.cmake

@@ -170,13 +170,7 @@ mark_as_advanced(SUPERLU_INCLUDE_DIR SUPERLU_LIBRARY)
 if(SUPERLU_FOUND)
   set(SUPERLU_INCLUDE_DIRS ${SUPERLU_INCLUDE_DIR})
   set(SUPERLU_LIBRARIES ${SUPERLU_LIBRARY})
-  set(SUPERLU_INT_TYPE int)
-  if(SUPERLU_MIN_VERSION_4_3)
-    set(HAVE_SLU_DDEFS_H 1)
-    check_include_files(slu_sdefs.h HAVE_SLU_SDEFS_H)
-    check_include_files(slu_cdefs.h HAVE_SLU_CDEFS_H)
-    check_include_files(slu_zdefs.h HAVE_SLU_ZDEFS_H)
-  endif()
+
   if (SUPERLU_BLAS_LIBRARY)
     list(APPEND SUPERLU_LIBRARIES ${SUPERLU_BLAS_LIBRARY})
   endif()

cmake/Modules/Finddune-grid.cmake

@@ -25,7 +25,6 @@ find_opm_package (
   "CXX11Features REQUIRED;
   dune-common REQUIRED;
   dune-geometry REQUIRED;
-  dune-uggrid;
   MPI;
   UG
   "

cmake/Modules/Finddune-istl.cmake

@@ -52,14 +52,7 @@ int main (void) {
   HAVE_PARMETIS;
   HAVE_SUPERLU;
   HAVE_UMFPACK;
-  HAVE_SUITESPARSE_UMFPACK;
-  SUPERLU_INT_TYPE;
-  HAVE_SLU_CDEFS_H;
-  HAVE_SLU_DDEFS_H;
-  HAVE_SLU_SDEFS_H;
-  HAVE_SLU_ZDEFS_H;
   SUPERLU_MIN_VERSION_4_3;
-  SUPERLU_MIN_VERSION_5;
   SUPERLU_POST_2005_VERSION
   ")
 #debug_find_vars ("dune-istl")

cmake/Modules/Finddune-uggrid.cmake

@@ -1,34 +0,0 @@
-include (OpmPackage)
-
-find_opm_package (
-  # module name
-  "dune-uggrid"
-
-  # dependencies
-  # TODO: we should probe for all the HAVE_* values listed below;
-  # however, we don't actually use them in our implementation, so
-  "CXX11Features REQUIRED;
-  dune-common REQUIRED
-  "
-  # header to search for
-  ""
-
-  # library to search for
-  "duneuggrid"
-
-  # defines to be added to compilations
-  ""
-
-  # test program
-  ""
-  # config variable
-  "")
-
-#debug_find_vars ("dune-uggrid")
-
-# make version number available in config.h
-include (UseDuneVer)
-find_dune_version ("dune" "uggrid")
-
-# deactivate search for UG
-set(UG_FOUND ${dune-uggrid_FOUND})

cmake/Modules/Findewoms.cmake

@@ -0,0 +1,42 @@
+# - Find OPM eWoms module
+#
+# Defines the following variables:
+#   ewoms_INCLUDE_DIRS    Directory of header files
+#   ewoms_LIBRARIES       Directory of shared object files
+#   ewoms_DEFINITIONS     Defines that must be set to compile
+#   ewoms_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_EWOMS            Binary value to use in config.h
+
+# Copyright (C) 2012 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (ewoms-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "ewoms"
+
+  # dependencies
+  "${ewoms_DEPS}"
+  
+  # header to search for
+  "ewoms/common/start.hh"
+
+  # library to search for
+  ""
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+"#include <ewoms/common/start.hh>
+int main (void) {
+return 0;
+}
+"
+  # config variables
+  "${ewoms_CONFIG_VAR}"
+  )
+#include (UseDynamicBoost)
+#debug_find_vars ("ewoms")

cmake/Modules/Findopm-common.cmake

@@ -0,0 +1,43 @@
+# - Find the opm-common module
+#
+# Defines the following variables:
+#   opm-common_INCLUDE_DIRS    Directory of header files
+#   opm-common_LIBRARIES       Directory of shared object files
+#   opm-common_DEFINITIONS     Defines that must be set to compile
+#   opm-common_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_OPM_COMMON            Binary value to use in config.h
+
+# Copyright (C) 2013 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (opm-common-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "opm-common"
+
+  # dependencies
+  "${opm-common_DEPS}"
+
+  # header to search for
+  "opm/common/utility/platform_dependent/disable_warnings.h"
+
+  # library to search for
+  "opmcommon"
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+  "#include <opm/common/utility/platform_dependent/disable_warnings.h>
+int main (void) {
+  return 0;  
+}
+"
+
+  # config variables
+  "${opm-common_CONFIG_VAR}"
+  )
+include (UseDynamicBoost)
+#debug_find_vars ("opm-common")

cmake/Modules/Findopm-core.cmake

@@ -0,0 +1,46 @@
+# - Find OPM core library
+#
+# Defines the following variables:
+#   opm-core_INCLUDE_DIRS    Directory of header files
+#   opm-core_LIBRARIES       Directory of shared object files
+#   opm-core_DEFINITIONS     Defines that must be set to compile
+#   opm-core_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_OPM_CORE            Binary value to use in config.h
+
+# Copyright (C) 2012 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (opm-core-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "opm-core"
+
+  # dependencies
+  "${opm-core_DEPS}"
+  
+  # header to search for
+  "opm/core/wells.h"
+
+  # library to search for
+  "opmcore"
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+"
+#include <opm/core/utility/parameters/ParameterGroup.hpp>
+int main()
+{
+    Opm::ParameterGroup parameters;
+    parameters.insertParameter(\"number\", \"7\");
+    return 0;
+}
+"
+  # config variables
+  "${opm-core_CONFIG_VAR}"
+  )
+include (UseDynamicBoost)
+#debug_find_vars ("opm-core")

cmake/Modules/Findopm-data.cmake

@@ -0,0 +1,24 @@
+# This module searches for the opm-data repository. Since the opm-data
+# has no libraries or header files the find implementation is quite
+# naive.
+#
+# If the opm-data repository is found, the following variables are set:
+#
+#   HAVE_OPM_DATA
+#   OPM_DATA_ROOT
+
+if (OPM_DATA_ROOT)
+   set( _opm_data_root ${OPM_DATA_ROOT})
+else()
+   set( _opm_data_root "${PROJECT_SOURCE_DIR}/../opm-data")
+endif()
+
+
+if (EXISTS "${_opm_data_root}/norne/NORNE_ATW2013.DATA")
+   set( HAVE_OPM_DATA True )
+   set( OPM_DATA_ROOT ${_opm_data_root} )
+   message(STATUS "Setting OPM_DATA_ROOT: ${OPM_DATA_ROOT}")
+else()
+   set( HAVE_OPM_DATA False )
+   message(WARNING "opm-data not found - integration tests using opm-data will be skipped.")
+endif()

cmake/Modules/Findopm-grid.cmake

@@ -0,0 +1,42 @@
+# - Find OPM corner-point grid library
+#
+# Defines the following variables:
+#   opm-grid_INCLUDE_DIRS    Directory of header files
+#   opm-grid_LIBRARIES       Directory of shared object files
+#   opm-grid_DEFINITIONS     Defines that must be set to compile
+#   opm-grid_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_OPM_GRID            Binary value to use in config.h
+
+# Copyright (C) 2013 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+include (opm-grid-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "opm-grid"
+
+  # dependencies
+  "${opm-grid_DEPS}"
+  
+  # header to search for
+  "dune/grid/cpgrid/GlobalIdMapping.hpp"
+
+  # library to search for
+  "opmgrid"
+
+  # defines to be added to compilations
+  "HAVE_OPM_GRID"
+
+  # test program
+"#include <dune/grid/cpgrid/GlobalIdMapping.hpp>
+int main (void) {
+  Dune::cpgrid::GlobalIdMapping g;
+  return 0;
+}
+"
+  # config variables
+  "${opm-grid_CONFIG_VAR}"
+  )
+
+#debug_find_vars ("opm-grid")

cmake/Modules/Findopm-material.cmake

@@ -0,0 +1,43 @@
+# - Find OPM materials library
+#
+# Defines the following variables:
+#   opm-material_INCLUDE_DIRS    Directory of header files
+#   opm-material_LIBRARIES       Directory of shared object files
+#   opm-material_DEFINITIONS     Defines that must be set to compile
+#   opm-material_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_OPM_MATERIAL            Binary value to use in config.h
+
+# Copyright (C) 2013 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (opm-material-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "opm-material"
+
+  # dependencies
+  "${opm-material_DEPS}"
+
+  # header to search for
+  "opm/material/Constants.hpp"
+
+  # library to search for
+  ""
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+"#include <opm/material/Constants.hpp>
+int main (void) {
+  double c = Opm::Constants<double>::c;
+  return 0;  
+}
+"
+  # config variables
+  "${opm-material_CONFIG_VAR}"
+  )
+include (UseDynamicBoost)
+#debug_find_vars ("opm-material")

cmake/Modules/Findopm-output.cmake

@@ -0,0 +1,44 @@
+# - Find OPM output library
+#
+# Defines the following variables:
+#   opm-output_INCLUDE_DIRS    Directory of header files
+#   opm-output_LIBRARIES       Directory of shared object files
+#   opm-output_DEFINITIONS     Defines that must be set to compile
+#   opm-output_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_OPM_OUTPUT            Binary value to use in config.h
+
+# Copyright (C) 2012 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (opm-output-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "opm-output"
+
+  # dependencies
+  "${opm-output_DEPS}"
+  
+  # header to search for
+  "opm/output/OutputWriter.hpp"
+
+  # library to search for
+  "opmoutput"
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+"#include <opm/output/eclipse/Summary.hpp>
+int main (void) {
+    return 0;
+}
+"
+  # config variables
+  "${opm-output_CONFIG_VAR}"
+  )
+include (UseDynamicBoost)
+#debug_find_vars ("opm-output")
+
+

cmake/Modules/Findopm-parser.cmake

@@ -0,0 +1,66 @@
+# Find the OPM Eclipse input parser.
+#
+# Set the cache variable OPM_PARSER_ROOT to the install location of the
+# library, or OPM_ROOT to the parent directory of the build tree.
+#
+# If found, it sets these variables:
+#
+#       HAVE_OPM_PARSER              Defined if a test program compiled
+#       OPM_PARSER_INCLUDE_DIRS      Header file directories
+#       OPM_PARSER_LIBRARIES         Archives and shared objects
+
+include (FindPackageHandleStandardArgs)
+
+# variables to pass on to other packages
+if (FIND_QUIETLY)
+  set (OPM_PARSER_QUIET "QUIET")
+else ()
+  set (OPM_PARSER_QUIET "")
+endif ()
+
+
+# inherit "suite" root if not specifically set for this library
+if ((NOT OPM_PARSER_ROOT) AND OPM_ROOT)
+  set (OPM_PARSER_ROOT "${OPM_ROOT}/opm-parser")
+endif ()
+
+# Detect the build dir suffix or subdirectory
+string(REGEX REPLACE "${PROJECT_SOURCE_DIR}/?(.*)" "\\1"  BUILD_DIR_SUFFIX "${PROJECT_BINARY_DIR}")
+
+# if a root is specified, then don't search in system directories
+# or in relative directories to this one
+if (OPM_PARSER_ROOT)
+  set (_no_default_path "NO_DEFAULT_PATH")
+  set (_opm_parser_source "")
+  set (_opm_parser_build "")
+else ()
+  set (_no_default_path "")
+  set (_opm_parser_source
+    "${PROJECT_SOURCE_DIR}/../opm-parser")
+  set (_opm_parser_build
+    "${PROJECT_BINARY_DIR}/../opm-parser"
+    "${PROJECT_BINARY_DIR}/../opm-parser${BUILD_DIR_SUFFIX}"
+    "${PROJECT_BINARY_DIR}/../../opm-parser/${BUILD_DIR_SUFFIX}")
+endif ()
+
+
+find_package(opm-parser CONFIG HINTS ${_opm_parser_build})
+if (opm-parser_FOUND)
+    find_package(ecl REQUIRED)
+    find_package(Boost 1.44.0
+                 COMPONENTS regex filesystem system date_time
+                 REQUIRED)
+    set(HAVE_OPM_PARSER 1)
+    # setting HAVE_ERT is a mega hack here, but some downstreams require it.
+    # Eventually projets should move on to properly handle dependencies and
+    # configurations, and Findopm-parser be deprecated
+    set(HAVE_ERT 1)
+    set(opm-parser_CONFIG_VARS HAVE_OPM_PARSER HAVE_REGEX HAVE_ERT)
+    set(opm-parser_LIBRARIES opmparser)
+
+    find_package_handle_standard_args(opm-parser
+        DEFAULT_MSG
+        opm-parser_LIBRARIES HAVE_OPM_PARSER HAVE_ERT
+    )
+endif ()
+

cmake/Modules/Findopm-simulators.cmake

@@ -0,0 +1,44 @@
+# - Find OPM automatic differentiation library
+#
+# Defines the following variables:
+#   opm-simulators_INCLUDE_DIRS    Directory of header files
+#   opm-simulators_LIBRARIES       Directory of shared object files
+#   opm-simulators_DEFINITIONS     Defines that must be set to compile
+#   opm-simulators_CONFIG_VARS     List of defines that should be in config.h
+#   HAVE_OPM_SIMULATORS            Binary value to use in config.h
+
+# Copyright (C) 2012 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (opm-simulators-prereqs)
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "opm-simulators"
+
+  # dependencies
+  "${opm-simulators_DEPS}"
+  
+  # header to search for
+  "opm/autodiff/AutoDiff.hpp"
+
+  # library to search for
+  "opmsimulators"
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+"#include <opm/autodiff/AutoDiff.hpp>
+int main (void) {
+  Opm::AutoDiff<double> x = Opm::AutoDiff<double>::constant(42.);
+  (void) x;
+  return 0;  
+}
+"
+  # config variables
+  "${opm-simulators_CONFIG_VAR}"
+  )
+include (UseDynamicBoost)
+#debug_find_vars ("opm-simulators")

cmake/Modules/Findopm-tests.cmake

@@ -1,27 +0,0 @@
-# This module searches for the opm-tests repository. Since opm-tests
-# has no libraries or header files the find implementation is quite
-# naive.
-#
-# If the opm-tests repository is found, the following variables are set:
-#
-#   HAVE_OPM_TESTS
-#   OPM_TESTS_ROOT
-
-if (OPM_TESTS_ROOT)
-   set( _opm_tests_root ${OPM_TESTS_ROOT})
-else()
-   set( _opm_tests_root "${PROJECT_SOURCE_DIR}/../opm-tests")
-endif()
-
-
-if (EXISTS "${_opm_tests_root}/norne/NORNE_ATW2013.DATA")
-   set( HAVE_OPM_DATA True )
-   set( HAVE_OPM_TESTS True )
-   set( OPM_TESTS_ROOT ${_opm_tests_root} )
-   set( OPM_DATA_ROOT ${_opm_tests_root} )
-   message(STATUS "Setting OPM_TESTS_ROOT: ${OPM_TESTS_ROOT}")
-else()
-   set( HAVE_OPM_TESTS False )
-   set( HAVE_OPM_DATA False )
-   message(WARNING "opm-tests not found - integration tests using opm-tests will be skipped.")
-endif()

cmake/Modules/LibtoolArchives.cmake

@@ -123,7 +123,7 @@ function (configure_la name target)
 	mark_as_advanced (libtool_MAIN)
 	# notify the user if it not found after we explicitly searched
 	if (NOT libtool_MAIN)
-	  message (STATUS "Not generating libtool archive (.la) since libtool was not found")
+	  message (STATUS "Libtool not found!")	  
 	endif (NOT libtool_MAIN)
   endif (NOT libtool_MAIN)
   if (libtool_MAIN)

cmake/Modules/OpmFiles.cmake

@@ -2,10 +2,8 @@
 
 macro (opm_out_dirs)
   # put libraries in lib/ (no multi-arch support in build tree)
-  if(MAIN_SOURCE_FILES)
-    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
-    set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
-  endif()
+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+  set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
   set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
   set (CMAKE_Fortran_MODULE_DIRECTORY "${PROJECT_BINARY_DIR}/CMakeFiles")
 endmacro (opm_out_dirs)

cmake/Modules/OpmFind.cmake

@@ -54,16 +54,13 @@ foreach (name IN LISTS _opm_proj_vars)
   endif (NOT DEFINED ${CMAKE_PROJECT_NAME}_${name})
 endforeach (name)
 
-# these dependencies needs special treatment
+# these dependencies must always be handled by the find module
 set (_opm_proj_exemptions
   dune-common
   dune-istl
   dune-grid
   dune-geometry
-  dune-uggrid
-  dune-alugrid
-  dune-localfunctions
-  dune-fem
+  opm-parser
   )
 
 # although a DUNE module, it is delivered in the OPM suite
@@ -139,12 +136,6 @@ macro (find_and_append_package_to prefix name)
 	set (${name}_FOUND FALSE)
 	set (${NAME}_FOUND FALSE)
   else ()
-    # List of components might differ for every module. Therefore we will
-    # need to research for a library multiple times. _search_components
-    # will hold the index of the string COMPONENTS in the list
-    set(_ARGN_LIST ${ARGN}) # Create a real list to use with list commands
-    list(FIND _ARGN_LIST "COMPONENTS" _search_components)
-
     # using config mode is better than using module (aka. find) mode
     # because then the package has already done all its probes and
     # stored them in the config file for us
@@ -153,53 +144,39 @@ macro (find_and_append_package_to prefix name)
     # We even need to repeat the search for opm-common once as this is done
     # in the top most CMakeLists.txt without querying defines, setting dependencies
     # and the likes which is only done via opm_find_package
-    if ( (NOT DEFINED ${name}_FOUND AND NOT DEFINED ${NAME}_FOUND )
-         OR _search_components GREATER -1)
+    if (NOT DEFINED ${name}_FOUND AND NOT DEFINED ${NAME}_FOUND
+        OR ("${name}" STREQUAL "opm-common" AND NOT _opm_common_deps_processed))
       string(REGEX MATCH "(dune|opm)-.*" _is_opm ${name})
-      if(NOT _is_opm)
-        string(REGEX MATCH "ewoms" _is_opm ${name})
-      endif()
-      if(${name} STREQUAL "ecl")
-        # Give us a chance to find ecl installed to CMAKE_INSTALL_PREFIX.
-        # We need to deactivate the package registry for this.
-        create_module_dir_var(ecl)
-        set(ARGN_NO_REQUIRED ${ARGN})
-        if(ARGN)
-          list(REMOVE_ITEM ARGN_NO_REQUIRED "REQUIRED")
+      if (${name}_DIR AND NOT (_${name}_exempted OR _is_opm))
+        message (STATUS "Finding package ${name} using config mode ${_${name}_exempted}")
+        find_package (${name} ${ARGN} NO_MODULE PATHS ${${name}_DIR} NO_DEFAULT_PATH)
+      else ()
+        # print message if this neither an opm module nor ecl
+        if (NOT (${name}_exempted EQUAL -1 OR _is_opm_) )
+          message (STATUS "Finding package ${name} using module mode")
         endif()
-        find_package (${name} ${ARGN_NO_REQUIRED} NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_PACKAGE_REGISTRY)
-        if(TARGET ecl)
-          # Need to grab from target to enable transitional depends
-          #get_target_property(ecl_INCLUDE_DIRS ecl INTERFACE_INCLUDE_DIRECTORIES)
-          set(ecl_LIBRARIES ecl)
-          set(HAVE_ERT 1)
-        endif()
-      elseif(_${name}_exempted LESS 0 AND NOT _is_opm)
-        find_package (${name} ${ARGN})
-      elseif(_${name}_exempted GREATER -1)
-        find_package (${name} ${ARGN})
-      else()
-        if(${name}_DIR)
-          find_package (${name} ${${prefix}_VERSION_MAJOR}.${${prefix}_VERSION_MINOR} ${ARGN} NO_MODULE PATHS ${${name}_DIR} NO_DEFAULT_PATH)
-        else()
-          find_package (${name} ${${prefix}_VERSION_MAJOR}.${${prefix}_VERSION_MINOR} ${ARGN} NO_MODULE)
-        endif()
-        include(FindPackageHandleStandardArgs)
-        if(${name}_FOUND AND ${name}_LIBRARY STREQUAL "")
-          find_package_handle_standard_args(${name}
-                                            REQUIRED_VARS ${name}_INCLUDE_DIRS)
-        else()
-          find_package_handle_standard_args(${name}
-                                            REQUIRED_VARS ${name}_LIBRARY)
-        endif()
-      endif ()
-    endif ()
-    if (NOT DEFINED ${name}_FOUND)
-      set (${name}_FOUND "${${NAME}_FOUND}")
-    endif ()
-    if (NOT DEFINED ${NAME}_FOUND)
-      set (${NAME}_FOUND "${${name}_FOUND}")
-    endif ()
+		if(${name} STREQUAL "ecl")
+			# Give us a chance to find ecl installed to CMAKE_INSTALL_PREFIX.
+			# We need to deactivate the package registry for this.
+			create_module_dir_var(ecl)
+			set(ARGN_NO_REQUIRED ${ARGN})
+			list(REMOVE_ITEM ARGN_NO_REQUIRED "REQUIRED")
+ 			find_package (${name} ${ARGN_NO_REQUIRED} NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_PACKAGE_REGISTRY)
+			# If everything else failed fall back to the registry
+		endif()	
+		find_package (${name} ${ARGN})
+	  endif ()
+	endif ()
+	if (NOT DEFINED ${name}_FOUND)
+	  set (${name}_FOUND "${${NAME}_FOUND}")
+	endif ()
+	if (NOT DEFINED ${NAME}_FOUND)
+	  set (${NAME}_FOUND "${${name}_FOUND}")
+	endif ()
+
+       if(name STREQUAL "opm-common")
+         set(_opm_common_deps_processed ON)
+       endif()
   endif ()
 
   # the variable "NAME" may be replaced during find_package (as this is

cmake/Modules/OpmInit.cmake

@@ -60,9 +60,6 @@ endmacro ()
 OpmInitProjVars ()
 OpmInitDirVars ()
 
-list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR})
-include(OpmPackage)
-
 # if we are backporting this release to a system which already have an
 # earlier version, set this flag to have everything scoped into a directory
 # which incorporates the label of the release. this is done by interjecting
@@ -74,17 +71,3 @@ if (USE_VERSIONED_DIR)
 else ()
   set (${project}_VER_DIR "")
 endif ()
-
-# parallel computing must be explicitly enabled
-# This needs to be in OpmInit as prereqs is called before OpmLibMain is included.
-option (USE_MPI "Use Message Passing Interface for parallel computing" OFF)
-if (NOT USE_MPI)
-  set (CMAKE_DISABLE_FIND_PACKAGE_MPI TRUE)
-endif ()
-
-# quadmath must be explicitly enabled
-# This needs to be in OpmInit as prereqs is called before OpmLibMain is included.
-option (USE_QUADMATH "Use high precision floating point library (slow)" OFF)
-if (NOT USE_QUADMATH)
-  set (CMAKE_DISABLE_FIND_PACKAGE_QuadMath TRUE)
-endif ()

cmake/Modules/OpmInstall.cmake

@@ -8,7 +8,7 @@
 # _TARGET           CMake target which builds the library
 # _LIBRARY_TYPE     Static or shared library
 # _DEBUG            File containing debug symbols
-include (GNUInstallDirs)
+include (UseMultiArch)
 
 macro (opm_install opm)
   foreach (_hdr IN LISTS ${opm}_HEADERS)
@@ -20,16 +20,10 @@ macro (opm_install opm)
 	  )
   endforeach (_hdr)
   install (
-	TARGETS ${${opm}_TARGET} ${${opm}_EXTRA_TARGETS}
-	EXPORT ${opm}-targets
+	TARGETS ${${opm}_TARGET}
 	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}${${opm}_VER_DIR}
 	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}${${opm}_VER_DIR}
 	)
-  if(NOT "${${opm}_TARGET}" STREQUAL "")
-    export(TARGETS ${${opm}_TARGET} ${${opm}_EXTRA_TARGETS}
-            FILE ${opm}-targets.cmake)
-    install(EXPORT ${opm}-targets DESTINATION "share/cmake/${opm}")
-  endif()
   # only /usr/lib/debug seems to be searched for debug info; if we have
   # write access to that directory (package installation), then default
   # to use it; otherwise put the debug files together with the library
@@ -65,10 +59,6 @@ macro (opm_install opm)
   # multiarch-aware and will thus put in lib64/ on RHEL and lib/ on Debian
   install (
 	FILES ${PROJECT_SOURCE_DIR}/dune.module
-	DESTINATION lib/${${opm}_VER_DIR}/dunecontrol/${${opm}_NAME}
+	DESTINATION ${LIBDIR_MULTIARCH_UNAWARE}${${opm}_VER_DIR}/dunecontrol/${${opm}_NAME}
 	)
-  install (
-        FILES ${PROJECT_SOURCE_DIR}/${CMAKE_PROJECT_NAME}-prereqs.cmake
-        DESTINATION ${CMAKE_INSTALL_PREFIX}/share/opm/cmake/Modules
-        )
 endmacro (opm_install opm)

cmake/Modules/OpmLibMain.cmake

@@ -90,6 +90,12 @@ include (UseOptimization)
 # dependencies, in case they alter the list of warnings
 include (UseWarnings)
 
+# parallel computing must be explicitly enabled
+option (USE_MPI "Use Message Passing Interface for parallel computing" OFF)
+if (NOT USE_MPI)
+	set (CMAKE_DISABLE_FIND_PACKAGE_MPI TRUE)
+endif (NOT USE_MPI)
+
 # parallel programming
 include (UseOpenMP)
 find_openmp (${project})
@@ -132,7 +138,7 @@ include (UseDebugSymbols)
 include (UseDynamicBoost)
 
 # needed for Debian installation scheme
-include (GNUInstallDirs)
+include (UseMultiArch)
 
 # Run conditional file hook
 files_hook()
@@ -270,11 +276,10 @@ if (COMMAND tests_hook)
 endif (COMMAND tests_hook)
 
 # make datafiles necessary for tests available in output directory
-opm_data (tests datafiles "${tests_DIR}")
-if(NOT BUILD_TESTING)
-  set(excl_all EXCLUDE_FROM_ALL)
-endif()
-opm_compile_satellites (${project} tests "${excl_all}" "${tests_REGEXP}")
+if (BUILD_TESTING)
+	opm_data (tests datafiles "${tests_DIR}")
+	opm_compile_satellites (${project} tests "" "${tests_REGEXP}")
+endif (BUILD_TESTING)
 
 # use this target to check local git commits
 add_custom_target(check-commits
@@ -288,6 +293,9 @@ add_custom_target(check-commits
 include (OpmDoc)
 opm_doc (${project} ${doxy_dir})
 
+# provide compatibility with using this build in dunecontrol
+include (DuneCompat)
+
 ### clean in-source builds ###
 include (OpmDistClean)
 opm_dist_clean (${project})

cmake/Modules/OpmPackage.cmake

@@ -59,7 +59,11 @@ macro (find_opm_package module deps header lib defs prog conf)
   # top most CMakeLists.txt but we still need to search for its
   # dependencies
   if (${MODULE}_FOUND OR ${module}_FOUND)
+    if (${module} STREQUAL "opm-common" AND NOT _opm_common_deps_processed)
+      set(_opm_common_deps_processed ON)
+    else()
       return ()
+    endif()
   endif ()
 
   # variables to pass on to other packages
@@ -80,11 +84,31 @@ macro (find_opm_package module deps header lib defs prog conf)
   # ${module}_CONFIG_VARS for dune modules.
   find_package(${module} ${_${module}_quiet} ${_${module}_required} CONFIG)
 
-  if(NOT ${module}_DEPS)
-    # set the dependencies used in find_package_deps
-    set(${module}_DEPS "${deps}")
-  endif()
-  find_package_deps(${module})
+
+  # period because it should be something that evaluates to true
+  # in find_package_handle_standard_args
+  set (${module}_ALL_PREREQS ".")
+  foreach (_dep IN ITEMS ${deps})
+	separate_arguments (_${module}_args UNIX_COMMAND ${_dep})
+	if (_${module}_args)
+	  # keep REQUIRED in the arguments only if we were required ourself
+	  # "required-ness" is not transitive as far as CMake is concerned
+	  # (i.e. if an optional package requests a package to be required,
+	  # the build will fail if it's not found)
+	  string (REPLACE "REQUIRED" "${_${module}_required}" _args_req "${_${module}_args}")
+	  find_and_append_package_to (${module} ${_args_req} ${_${module}_quiet})
+	  list (GET _${module}_args 0 _name_only)
+	  string (TOUPPER "${_name_only}" _NAME_ONLY)
+	  string (REPLACE "-" "_" _NAME_ONLY "${_NAME_ONLY}")
+	  # check manually if it was found if REQUIRED; otherwise poison the
+	  # dependency list which is checked later (so that it will fail)
+	  if (("${_${module}_args}" MATCHES "REQUIRED") AND NOT (${_name_only}_FOUND OR ${_NAME_ONLY}_FOUND))
+		list (APPEND ${module}_ALL_PREREQS "${_name_only}-NOTFOUND")
+	  endif ()
+	else ()
+	  message (WARNING "Empty dependency in find module for ${module} (check for trailing semi-colon)")
+	endif ()
+  endforeach (_dep)
 
   # since find_and_append_package_to is a macro, this variable have
   # probably been overwritten (due to its common name); it is now
@@ -150,63 +174,6 @@ macro (find_opm_package module deps header lib defs prog conf)
   endif (${module}_DEBUG)
 endmacro (find_opm_package module deps header lib defs prog conf)
 
-macro (find_package_deps module)
-  # period because it should be something that evaluates to true
-  # in find_package_handle_standard_args
-  set (${module}_ALL_PREREQS ".")
-  foreach (_dep IN ITEMS ${${module}_DEPS})
-	separate_arguments (_${module}_args UNIX_COMMAND "${_dep}")
-	if (_${module}_args)
-          # keep REQUIRED in the arguments only if we were required ourself
-          # "required-ness" is not transitive as far as CMake is concerned
-          # (i.e. if an optional package requests a package to be required,
-          # the build will fail if it's not found)
-	  string (REPLACE "REQUIRED" "${_${module}_required}" _args_req "${_${module}_args}")
-          if(_dep MATCHES "opm-" OR _dep MATCHES "ewoms")
-            set(deplist ${_dep})
-            string(STRIP "${_dep}" _dep)
-            string(REPLACE " " ";" deplist "${_dep}")
-            list(GET deplist 0 depname)
-            create_module_dir_var(${depname})
-          endif()
-	  find_and_append_package_to (${module} ${_${module}_args} ${_${module}_quiet})
-	  list (GET _${module}_args 0 _name_only)
-	  string (TOUPPER "${_name_only}" _NAME_ONLY)
-	  string (REPLACE "-" "_" _NAME_ONLY "${_NAME_ONLY}")
-	  # check manually if it was found if REQUIRED; otherwise poison the
-	  # dependency list which is checked later (so that it will fail)
-	  if (("${_${module}_args}" MATCHES "REQUIRED") AND NOT (${_name_only}_FOUND OR ${_NAME_ONLY}_FOUND))
-		list (APPEND ${module}_ALL_PREREQS "${_name_only}-NOTFOUND")
-	  endif ()
-	else ()
-	  message (WARNING "Empty dependency in find module for ${module} (check for trailing semi-colon)")
-	endif ()
-  endforeach (_dep)
-
-  # tidy the lists before returning them
-  remove_dup_deps (${module})
-
-  # these defines are used in dune/${module} headers, and should be put
-  # in config.h when we include those
-  foreach (_var IN ITEMS ${conf})
-    # massage the name to remove source code formatting
-    string (REGEX REPLACE "^[\n\t\ ]+" "" _var "${_var}")
-    string (REGEX REPLACE "[\n\t\ ]+$" "" _var "${_var}")
-    list (APPEND ${module}_CONFIG_VARS ${_var})
-  endforeach (_var)
-
-  # these are the defines that should be set when compiling
-  # without config.h
-  config_cmd_line (${module}_CMD_CONFIG ${module}_CONFIG_VARS)
-
-  # This variable is used by UseDuneVer
-  list(GET ${module}_INCLUDE_DIRS 0 ${module}_INCLUDE_DIR)
-  # print everything out if we're asked to
-  if (${module}_DEBUG)
-	debug_find_vars (${module})
-  endif (${module}_DEBUG)
-endmacro ()
-
 # print all variables defined by the above macro
 function (debug_find_vars module)
   message (STATUS "${module}_FOUND        = ${${module}_FOUND}")
@@ -216,7 +183,7 @@ function (debug_find_vars module)
   message (STATUS "${module}_CONFIG_VARS  = ${${module}_CONFIG_VARS}")
   message (STATUS "${module}_LINKER_FLAGS = ${${module}_LINKER_FLAGS}")
   string (TOUPPER ${module} MODULE)
-  string (REPLACE "-" "_" MODULE ${MODULE})
+  string (REPLACE "-" "_" MODULE ${MODULE})  
   message (STATUS "HAVE_${MODULE}         = ${HAVE_${MODULE}}")
 endfunction (debug_find_vars module)
 

cmake/Modules/OpmProject.cmake

@@ -56,9 +56,6 @@ function (configure_cmake_file name variant version)
 	set (opm-project_${suffix} "${${name}_${suffix}}")
   endforeach (suffix)
   set (opm-project_NAME "${${name}_NAME}")
-  set (opm-project_NAME_UC "${${name}_NAME}")
-  string(TOUPPER "${opm-project_NAME}" opm-project_NAME_UC)
-  string(REPLACE "-" "_" opm-project_NAME_UC "${opm-project_NAME_UC}")
 
   # make the file substitutions
   configure_file (
@@ -76,9 +73,7 @@ function (opm_cmake_config name)
   set (template_dir "${OPM_MACROS_ROOT}/cmake/Templates")
 
   # write configuration file to locate library
-  set(DUNE_PREFIX ${PROJECT_SOURCE_DIR})
   set(OPM_PROJECT_EXTRA_CODE ${OPM_PROJECT_EXTRA_CODE_INTREE})
-  set(PREREQ_LOCATION "${PROJECT_SOURCE_DIR}")
   configure_cmake_file (${name} "config" "")
   configure_cmake_file (${name} "config" "-version")
   configure_vars (
@@ -92,17 +87,10 @@ function (opm_cmake_config name)
 	${template_dir}/opm-project.pc.in
 	${PROJECT_BINARY_DIR}/${${name}_NAME}.pc
 	${PROJECT_BINARY_DIR}
-	"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+	${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
 	${PROJECT_SOURCE_DIR}
 	)
 
-  # The next replace will result in bogus entries if install directory is
-  # a subdirectory of source tree,
-  # and we have existing entries pointing to that install directory.
-  # Since they will yield a duplicate in next replace anyways, we filter them out first
-  # to get avoid those the bogus entries.
-  string(REPLACE "${CMAKE_INSTALL_PREFIX}/include${${name}_VER_DIR}" "" ${name}_INCLUDE_DIRS "${${name}_INCLUDE_DIRS}")
-
   # replace the build directory with the target directory in the
   # variables that contains build paths
   string (REPLACE
@@ -123,8 +111,6 @@ function (opm_cmake_config name)
   # create a config mode file which targets the install directory instead
   # of the build directory (using the same input template)
   set(OPM_PROJECT_EXTRA_CODE ${OPM_PROJECT_EXTRA_CODE_INSTALLED})
-  set(PREREQ_LOCATION "${CMAKE_INSTALL_PREFIX}/share/opm/cmake/Modules")
-  set(DUNE_PREFIX ${CMAKE_INSTALL_PREFIX})
   configure_cmake_file (${name} "install" "")
   configure_vars (
 	FILE CMAKE "${PROJECT_BINARY_DIR}/${${name}_NAME}-install.cmake"
@@ -158,7 +144,7 @@ function (opm_cmake_config name)
   if (${name}_TARGET)
 	set (_pkg_dir ${CMAKE_INSTALL_LIBDIR})
   else ()
-	set (_pkg_dir lib)
+	set (_pkg_dir ${LIBDIR_MULTIARCH_UNAWARE})
   endif ()
   install (
 	FILES ${PROJECT_BINARY_DIR}/${${name}_NAME}-install.pc

cmake/Modules/OpmSatellites.cmake

@@ -65,11 +65,6 @@ macro (opm_compile_satellites opm satellite excl_all test_regexp)
 	set_target_properties (${_sat_NAME} PROPERTIES
 	  LINK_FLAGS "${${opm}_LINKER_FLAGS_STR}"
 	  )
-        if(HAVE_DYNAMIC_BOOST_TEST AND NOT (${opm} STREQUAL "opm-parser" AND NOT BUILD_SHARED_LIBS))
-	  set_target_properties (${_sat_NAME} PROPERTIES
-		  COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK
-	  )
-	endif()
 	# are we building a test? luckily, the testing framework doesn't
 	# require anything else, so we don't have to figure out where it
 	# should go in the library list
@@ -87,14 +82,11 @@ macro (opm_compile_satellites opm satellite excl_all test_regexp)
 
 	# variable with regular expression doubles as a flag for
 	# whether tests should be setup or not
-	set(_sat_FANCY)
 	if (NOT "${test_regexp}" STREQUAL "")
 	  foreach (_regexp IN ITEMS ${test_regexp})
 		if ("${_sat_NAME}" MATCHES "${_regexp}")
 		  string (REGEX REPLACE "${_regexp}" "\\1" _sat_FANCY "${_sat_NAME}")
-		elseif(NOT _sat_FANCY)
-		  set(_sat_FANCY ${_sat_NAME})
-		endif()
+		endif ("${_sat_NAME}" MATCHES "${_regexp}")
 	  endforeach (_regexp)
 	  get_target_property (_sat_LOC ${_sat_NAME} LOCATION)
           # Run tests through mpi-run. Ubuntu 14.04 provided mpi libs will crash
@@ -147,7 +139,7 @@ macro (opm_data satellite target dirname)
   # even if there are no datafiles, create the directory so the
   # satellite programs have a homedir to run in
   execute_process (
-	COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${dirname}
+	COMMAND ${CMAKE_COMMAND} -E make_directory ${dirname}
 	)
 
   # if ever huge test datafiles are necessary, then change this
@@ -275,7 +267,7 @@ macro(opm_add_test TestName)
 
   # the libraries to link against
   if (NOT CURTEST_LIBRARIES)
-    SET(CURTEST_LIBRARIES "${${project}_LIBRARIES}")
+    SET(CURTEST_LIBRARIES "${${CMAKE_PROJECT_NAME}_LIBRARIES}")
   endif()
 
   # determine if the test should be completely ignored, i.e., the
@@ -297,9 +289,6 @@ macro(opm_add_test TestName)
       add_executable("${CURTEST_EXE_NAME}" ${CURTEST_EXCLUDE_FROM_ALL} ${CURTEST_SOURCES})
       target_link_libraries (${CURTEST_EXE_NAME} ${CURTEST_LIBRARIES})
 
-      if(TARGET ${project}_prepare)
-        add_dependencies("${CURTEST_EXE_NAME}" ${project}_prepare)
-      endif()
       if(CURTEST_DEPENDS)
         add_dependencies("${CURTEST_EXE_NAME}" ${CURTEST_DEPENDS})
       endif()
@@ -314,9 +303,6 @@ macro(opm_add_test TestName)
         if(CURTEST_DEPENDS)
           add_dependencies("${CURTEST_EXE_NAME}" ${CURTEST_DEPENDS})
         endif()
-        if(TARGET ${project}_prepare)
-          add_dependencies("${CURTEST_EXE_NAME}" ${project}_prepare)
-        endif()
       endif()
 
       # figure out how the test should be run. if a test driver script

cmake/Modules/OpmSiblingSearch.cmake

@@ -9,7 +9,7 @@ macro(create_module_dir_var module)
     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 ("${module}" STREQUAL "ecl")
+    if (module STREQUAL "ecl")
       #use clone directory libecl
       set(_clone_dir "libecl")
     else()
@@ -25,7 +25,7 @@ macro(create_module_dir_var module)
         set(${module}_DIR ${_parent_full_dir}/${_module_leaf})
       elseif(IS_DIRECTORY ${_parent_full_dir}/${_clone_dir})
         # All modules are in a common build dir
-        set(${module}_DIR "${_parent_full_dir}/${_clone_dir}")
+        set(${module}_DIR "${_parent_full_dir}/${_clone_dir}}")
       endif()
     endif()
   endif()

cmake/Modules/OpmStaticTargets.cmake

@@ -50,7 +50,7 @@ macro(opm_static_add_dependencies target)
 endmacro()
 
 include(ExternalProject)
-include(GNUInstallDirs)
+include(UseMultiArch)
 
 # Defaults to building master
 if(NOT OPM_BENCHMARK_VERSION)

cmake/Modules/UseDuneVer.cmake

@@ -14,19 +14,139 @@
 # Add these variables to ${project}_CONFIG_IMPL_VARS in CMakeLists.txt
 # if you need these in the code.
 
+include (UseMultiArch)
+
 function (find_dune_version suite module)
-  # CMake's find_package will set <package>_VERSION_(MAJOR|MINOR|REVISION)
-  # we simply rely on that.
+  # the _ROOT variable may or may not be set, but the include
+  # variable should always be; get the prefix from the header path
+  # if we have a multilib installation where the package maintainer
+  # have installed it in e.g. /usr/include/dune-2.2/dune/istl, then
+  # stash this extra indirection and add it back later in lib/
+  set (_inc_path "${${suite}-${module}_INCLUDE_DIR}")
+  file (TO_CMAKE_PATH _inc_path "${_inc_path}")
+  set (_multilib_regexp "(.*)/include(/${suite}[^/]+)?")
+  if (_inc_path MATCHES "${_multilib_regexp}")
+	set (_orig_inc "${_inc_path}")
+	string (REGEX REPLACE "${_multilib_regexp}" "\\1" _inc_path "${_orig_inc}")
+	# only get the second group if it is really there (there is
+	# probably a better way to do this in CMake)
+	if ("${_inc_path}/include" STREQUAL "${_orig_inc}")
+	  set (_multilib "")
+	else ()
+	  string (REGEX REPLACE "${_multilib_regexp}" "\\2" _multilib "${_orig_inc}")
+	endif ()
+  else ()
+	set (_multilib "")
+  endif ()
+
+  # some modules does not have a library, use the directory of the
+  # header files to find what would be the library dir.
+  # note that when we refer to a build tree, then the libraries always
+  # go into lib/, but we don't care about that because in that case,
+  # dune.module isn't in the lib/ directory anyway but must be retrieved
+  # from the source. hence, we only have to worry about the library
+  # directory of a system installation here.
+  if (NOT ${suite}-${module}_LIBRARY)
+	# this suffix is gotten from UseMultiArch.cmake
+	set (_lib_path "${_inc_path}/${CMAKE_INSTALL_LIBDIR}")
+  else ()
+	get_filename_component (_lib_path "${${suite}-${module}_LIBRARY}" PATH)
+  endif ()
+
+  # if we have a source tree, dune.module is available there
+  set (_dune_mod "${_inc_path}/dune.module")
+  if (NOT EXISTS "${_dune_mod}")
+	set (_last_dune_mod_src "${_dune_mod}")
+	set (_dune_mod "")
+  endif ()
+
+  if (NOT _dune_mod)
+	# look for the build tree; if we found the library, then the
+	# dune.module file should be in a sub-directory  
+	get_filename_component (_immediate "${_lib_path}" NAME)
+	if ("${_immediate}" STREQUAL ".libs")
+	  # remove autotools internal path
+	  get_filename_component (_lib_path "${_lib_path}" PATH)
+	endif ()
+	get_filename_component (_immediate "${_lib_path}" NAME)
+	if ("${_immediate}" STREQUAL "${CMAKE_LIBRARY_ARCHITECTURE}")
+	  # remove multi-arch part of the library path to get parent
+	  get_filename_component (_lib_path "${_lib_path}" PATH)
+	endif ()
+	get_filename_component (_immediate "${_lib_path}" NAME)	
+	if (("${_immediate}" STREQUAL "${CMAKE_INSTALL_LIBDIR}")
+		OR ("${_immediate}" STREQUAL "lib")
+		OR ("${_immediate}" STREQUAL "${LIBDIR_MULTIARCH_UNAWARE}"))
+	  # remove library part of the path; this also undo the suffix
+	  # we added if we used the library as a standin
+	  get_filename_component (_lib_path "${_lib_path}" PATH)
+	endif ()
+	# from this point on, _lib_path does not contain an architecture-
+	# specific component anymore; dune.module is always put in straight
+	# noarch lib/ since it does not contain any paths to binaries
+	set (_suffix "${_multilib}/dunecontrol/${suite}-${module}/dune.module")
+	set (_dune_mod "${_lib_path}/${LIBDIR_MULTIARCH_UNAWARE}${_suffix}")
+	if (NOT EXISTS "${_dune_mod}")
+	  set (_last_dune_mod_bld "${_dune_mod}")
+	  # one more try, if we have a private install, then it doesn't use
+	  # e.g. lib64 but always lib (!)
+	  if ("${LIBDIR_MULTIARCH_UNAWARE}" STREQUAL "lib")
+		set (_dune_mod "")
+	  else ()
+		set (_dune_mod "${_lib_path}/lib${_suffix}")
+		if (NOT EXISTS "${_dune_mod}")
+		  set (_last_dune_mod_pri "${_dune_mod}")
+		  # use the name itself as a flag for whether it was found or not
+		  set (_dune_mod "")
+		endif ()
+	  endif ()
+	endif ()
+  endif ()
+
+  # if it is not available, it may make havoc having empty defines in the source
+  # code later, so we bail out early
+  if (NOT _dune_mod)
+	if (${suite}-${module}_FOUND)
+	  set (_searched_paths "\"${_last_dune_mod_src}\"")
+	  if (NOT ("${_last_dune_mod_bld}" STREQUAL ""))
+		set (_searched_paths "either ${_searched_paths} or \"${_last_dune_mod_bld}\"")
+	  endif ()
+	  if (NOT ("${_last_dune_mod_pri}" STREQUAL ""))
+		set (_searched_paths "${_searched_paths} or \"${_last_dune_mod_pri}\"")
+	  endif ()
+	  message (FATAL_ERROR "Failed to locate dune.module for ${suite}-${module} (looking for ${_searched_paths})")
+	else ()
+	  return ()
+	endif ()
+  endif ()
+
+  # parse the file for the Version: field
+  set (_ver_regexp "[ ]*Version:[ ]*([0-9]+)\\.([0-9]+)(.*)")
+  file (STRINGS "${_dune_mod}" _ver_field REGEX "${_ver_regexp}")
+  string (REGEX REPLACE "${_ver_regexp}" "\\1" _major "${_ver_field}")
+  string (REGEX REPLACE "${_ver_regexp}" "\\2" _minor "${_ver_field}")
+  string (REGEX REPLACE "${_ver_regexp}" "\\3" _revision "${_ver_field}")
+
+  # revision may or may not be there
+  set (_rev_regexp "\\.([0-9]+).*")
+  if (_revision MATCHES "${_rev_regexp}")
+	string (REGEX REPLACE "${_rev_regexp}" "\\1" _revision "${_revision}")
+  else ()
+	set (_revision "0")
+  endif ()
+
   # generate variable for what we have found
   string (TOUPPER "${suite}" _SUITE)
   string (TOUPPER "${module}" _MODULE)
   string (REPLACE "-" "_" _MODULE "${_MODULE}")
-  set (${_SUITE}_${_MODULE}_VERSION_MAJOR "${${suite}-${module}_VERSION_MAJOR}" PARENT_SCOPE)
-  set (${_SUITE}_${_MODULE}_VERSION_MINOR "${${suite}-${module}_VERSION_MINOR}" PARENT_SCOPE)
-  set (${_SUITE}_${_MODULE}_VERSION_REVISION "${${suite}-${module}_VERSION_PATCH}" PARENT_SCOPE)
+  if ((NOT DEFINED ${_SUITE}_${_MODULE}_VERSION_MAJOR) AND
+	  (NOT DEFINED ${_SUITE}_${_MODULE}_VERSION_MINOR) AND
+	  (NOT DEFINED ${_SUITE}_${_MODULE}_VERSION_REVISION))
+	set (${_SUITE}_${_MODULE}_VERSION_MAJOR "${_major}" PARENT_SCOPE)
+	set (${_SUITE}_${_MODULE}_VERSION_MINOR "${_minor}" PARENT_SCOPE)
+	set (${_SUITE}_${_MODULE}_VERSION_REVISION "${_revision}" PARENT_SCOPE)
+  endif ()
 
-  if( ${suite}-${module}_FOUND )
-    # print the version number we detected in the configuration log
-    message (STATUS "Version ${${suite}-${module}_VERSION_MAJOR}.${${suite}-${module}_VERSION_MINOR}.${${suite}-${module}_VERSION_PATCH} of ${suite}-${module} from ${${suite}-${module}_DIR}")
-  endif()
+  # print the version number we detected in the configuration log
+  message (STATUS "Version ${_major}.${_minor}.${_revision} of ${suite}-${module} from ${_dune_mod}")  
 endfunction (find_dune_version suite module)

cmake/Modules/UseMultiArch.cmake

@@ -0,0 +1,35 @@
+# - Multiarch support in object code library directories
+#
+# This module sets the following variable
+#	CMAKE_INSTALL_LIBDIR	     to lib, lib64 or lib/x86_64-linux-gnu
+#	                             depending on the platform; use this path
+#	                             for platform-specific binaries.
+#
+# Note that it will override the results of GNUInstallDirs if included after
+# that module.
+
+# default if we need to put something in the library directory for a
+# component that is *not* multiarch-aware
+set (LIBDIR_MULTIARCH_UNAWARE "lib")
+
+# Fedora uses lib64/ for 64-bit systems, Debian uses lib/x86_64-linux-gnu
+if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
+  # Debian or Ubuntu?
+  if (EXISTS "/etc/debian_version")
+	set (_libdir_def "lib/${CMAKE_LIBRARY_ARCHITECTURE}")
+  else (EXISTS "/etc/debian_version")
+	# 64-bit system?
+	if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+	  set (_libdir_def "lib64")
+	  set (LIBDIR_MULTIARCH_UNAWARE "${_libdir_def}")
+	else (CMAKE_SIZEOF_VOID_P EQUAL 8)
+	  set (_libdir_def "lib")
+	endif (CMAKE_SIZEOF_VOID_P EQUAL 8)
+  endif (EXISTS "/etc/debian_version")
+else ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
+  set (_libdir_def "lib")
+endif ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
+
+# let the user override if somewhere else is desirable
+set (CMAKE_INSTALL_LIBDIR "${_libdir_def}" CACHE PATH "Object code libraries")
+mark_as_advanced (CMAKE_INSTALL_LIBDIR)

cmake/Modules/UseOptimization.cmake

@@ -44,11 +44,7 @@ if (CXX_COMPAT_GCC)
   add_options (ALL_LANGUAGES "${_prof_DEBUG}" ${_opt_dbg} "-DDEBUG")
 
   # use these options for release builds - full optimization
-  add_options (ALL_LANGUAGES "${_prof_RELEASE}" ${_opt_rel} ${_opt_flags})
-  option(WITH_NDEBUG "Disable asserts in release mode" ON)
-  if(WITH_NDEBUG)
-    add_options (ALL_LANGUAGES "${_prof_RELEASE}" -DNDEBUG)
-  endif()
+  add_options (ALL_LANGUAGES "${_prof_RELEASE}" ${_opt_rel} "-DNDEBUG" ${_opt_flags})
 
 else ()
   # default information from system

cmake/Modules/ewoms-prereqs.cmake

@@ -0,0 +1,43 @@
+# -*- 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:
+
+# this avoids an annoying deprecation warning on DUNE 2.4 (which we
+# are not interested in anyway)
+set(DUNE_AVOID_CAPABILITIES_IS_PARALLEL_DEPRECATION_WARNING 1)
+
+# defines that must be present in config.h for our headers
+set (ewoms_CONFIG_VAR
+	HAVE_QUAD
+	HAVE_VALGRIND
+	HAVE_DUNE_COMMON
+	HAVE_DUNE_GEOMETRY
+	HAVE_DUNE_GRID
+	HAVE_DUNE_LOCALFUNCTIONS
+	HAVE_DUNE_ISTL
+	HAVE_DUNE_ALUGRID
+	HAVE_DUNE_FEM
+	DUNE_AVOID_CAPABILITIES_IS_PARALLEL_DEPRECATION_WARNING
+	)
+
+# dependencies
+set (ewoms_DEPS
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	# DUNE prerequisites
+	"dune-common REQUIRED"
+	"dune-geometry REQUIRED"
+	"dune-grid REQUIRED"
+	"dune-istl REQUIRED"
+	"opm-common REQUIRED"
+	"opm-material REQUIRED"
+	"dune-localfunctions"
+	"dune-alugrid"
+	"dune-fem"
+	"opm-parser"
+	"opm-grid"
+	"opm-core"
+	# valgrind client requests
+	"Valgrind"
+	# quadruple precision floating point calculations
+	"Quadmath"
+	)

cmake/Modules/opm-common-prereqs.cmake

@@ -0,0 +1,17 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-common_CONFIG_VAR
+	"HAS_ATTRIBUTE_UNUSED")
+
+# dependencies
+set (opm-common_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	# various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS system unit_test_framework REQUIRED"
+	)

cmake/Modules/opm-core-prereqs.cmake

@@ -0,0 +1,50 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-core_CONFIG_VAR
+	HAVE_ERT
+	HAVE_SUITESPARSE_UMFPACK_H
+	HAVE_DUNE_ISTL
+	HAVE_MPI
+	HAVE_PETSC
+        DUNE_ISTL_VERSION_MAJOR
+        DUNE_ISTL_VERSION_MINOR
+        DUNE_ISTL_VERSION_REVISION
+	)
+
+# dependencies
+set (opm-core_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	# various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS date_time filesystem system unit_test_framework REQUIRED"
+	# matrix library
+	"BLAS REQUIRED"
+	"LAPACK REQUIRED"
+	# Tim Davis' SuiteSparse archive
+	"SuiteSparse COMPONENTS umfpack"
+	# solver
+	"SuperLU"
+	# Ensembles-based Reservoir Tools (ERT)
+	"ecl REQUIRED"
+	# Look for MPI support
+	"MPI"
+	# PETSc numerical backend
+	"PETSc"
+	# DUNE dependency
+	"dune-common"
+	"dune-istl"
+	"opm-common REQUIRED"
+	# Parser library for ECL-type simulation models
+	"opm-parser REQUIRED"
+	# the code which implements the material laws
+	"opm-material REQUIRED"
+	# the code which implements the output routines
+	"opm-output REQUIRED"
+	# the code which implements grids
+	"opm-grid REQUIRED"
+	)

cmake/Modules/opm-flowdiagnostics-applications-prereqs.cmake

@@ -0,0 +1,21 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-flowdiagnostics-applications_CONFIG_VAR
+	)
+
+# dependencies
+set (opm-flowdiagnostics-applications_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	"Boost 1.44.0
+		COMPONENTS filesystem regex system unit_test_framework REQUIRED"
+	"ecl REQUIRED"
+	# prerequisite OPM modules
+	"opm-common REQUIRED;
+	opm-flowdiagnostics REQUIRED;
+	opm-core REQUIRED"
+	)

cmake/Modules/opm-flowdiagnostics-prereqs.cmake

@@ -0,0 +1,18 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-flowdiagnostics_CONFIG_VAR
+	)
+
+# dependencies
+set (opm-flowdiagnostics_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	"Boost 1.44.0
+		COMPONENTS unit_test_framework REQUIRED"
+	# prerequisite OPM modules
+	"opm-common REQUIRED"
+	)

cmake/Modules/opm-grid-prereqs.cmake

@@ -0,0 +1,36 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-grid_CONFIG_VAR
+	DUNE_GRID_VERSION_MAJOR
+	DUNE_GRID_VERSION_MINOR
+	DUNE_GRID_VERSION_REVISION
+	DUNE_GEOMETRY_VERSION_MAJOR
+	DUNE_GEOMETRY_VERSION_MINOR
+	DUNE_GEOMETRY_VERSION_REVISION
+	DUNE_COMMON_VERSION_MAJOR
+	DUNE_COMMON_VERSION_MINOR
+	DUNE_COMMON_VERSION_REVISION
+	HAVE_DUNE_ISTL
+	HAVE_MPI
+	HAVE_ZOLTAN
+	)
+
+# dependencies
+set (opm-grid_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features"
+	# various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS date_time filesystem system unit_test_framework REQUIRED"
+	"MPI"
+	"dune-common"
+	"dune-grid REQUIRED"
+	"dune-istl"
+	"opm-common REQUIRED"
+	"opm-parser REQUIRED"
+	"ZOLTAN"
+	)

cmake/Modules/opm-material-prereqs.cmake

@@ -0,0 +1,25 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-material_CONFIG_VAR
+	HAVE_MPI
+	HAVE_TYPE_TRAITS
+	HAVE_VALGRIND
+	HAVE_FINAL
+	)
+
+# dependencies
+set (opm-material_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	# prerequisite OPM modules
+	"opm-parser"
+	"opm-common REQUIRED"
+	# DUNE dependency
+	"dune-common REQUIRED"
+	# valgrind client requests
+	"Valgrind"
+	)

cmake/Modules/opm-output-prereqs.cmake

@@ -0,0 +1,24 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-output_CONFIG_VAR
+	HAVE_ERT
+	)
+
+# dependencies
+set (opm-output_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	# various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS unit_test_framework REQUIRED"
+	# Ensembles-based Reservoir Tools (ERT)
+	"ecl REQUIRED"
+	# Look for MPI support
+	"opm-common REQUIRED"
+	# Parser library for ECL-type simulation models
+	"opm-parser REQUIRED"
+	)

cmake/Modules/opm-simulators-prereqs.cmake

@@ -0,0 +1,39 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-simulators_CONFIG_VAR
+	HAVE_OPM_GRID
+	HAVE_PTHREAD
+	HAVE_EWOMS
+        DUNE_ISTL_VERSION_MAJOR
+        DUNE_ISTL_VERSION_MINOR
+        DUNE_ISTL_VERSION_REVISION
+	HAVE_SUITESPARSE_UMFPACK
+	)
+
+# dependencies
+set (opm-simulators_DEPS
+	# Compile with C99 support if available
+	"C99"
+	# Compile with C++0x/11 support if available
+	"CXX11Features"
+	# Various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS date_time filesystem system unit_test_framework REQUIRED"
+	# DUNE prerequisites
+	"dune-common REQUIRED;
+	dune-istl REQUIRED"
+	"ERTPython"
+	# Tim Davis' SuiteSparse archive
+	"SuiteSparse COMPONENTS umfpack"
+  # OPM dependency
+	"opm-common REQUIRED;
+   opm-parser REQUIRED;
+	 opm-grid REQUIRED;
+	 opm-core REQUIRED;
+	 opm-output REQUIRED;
+	 ewoms REQUIRED"
+	# Eigen
+	"Eigen3 3.2.0"
+	)

cmake/Modules/opm-upscaling-prereqs.cmake

@@ -0,0 +1,32 @@
+# -*- 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:
+
+# defines that must be present in config.h for our headers
+set (opm-upscaling_CONFIG_VAR
+	HAVE_SUPERLU
+	)
+
+# dependencies
+set (opm-upscaling_DEPS
+	# compile with C99 support if available
+	"C99"
+	# compile with C++0x/11 support if available
+	"CXX11Features"
+	# various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS date_time filesystem system iostreams unit_test_framework REQUIRED"
+	# matrix library
+	"BLAS REQUIRED"
+	"LAPACK REQUIRED"
+	# solver
+	"SuperLU"
+	# DUNE dependency
+	"dune-common REQUIRED;
+	dune-istl REQUIRED;
+	dune-geometry REQUIRED;
+	dune-grid REQUIRED;
+	opm-common REQUIRED;
+  opm-grid REQUIRED;
+	opm-core REQUIRED;
+	opm-output REQUIRED"
+	)

cmake/Scripts/configure

@@ -0,0 +1,553 @@
+#!/bin/bash
+
+# where is the source tree located by default relative to here
+srcdir=$(dirname "$(dirname "$(dirname "$0")")")
+
+# display help text
+usage () {
+  cat <<EOF
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          [/usr/local]. Note: set DESTDIR=PATH when doing
+                          \`make install' to install to a different sysroot.
+
+Optional Features:
+  --disable-FEATURE       do not include FEATURE
+  --disable-gxx11check    do not try flag -std=c++11 to enable C++11 features
+  --enable-shared         build a shared library [default=yes]
+  --enable-static         build a static library [default=no]. Note: only one
+                          of the options shared and static may be built.
+  --enable-debug          build a non-optimized version of the library
+                          [default=no]
+  --disable-runpath       do not use RUNPATH in installed library [default=yes]
+  --enable-lto            use whole program optimization [default=no]
+  --enable-strip-debug    separate the executable code and the debugging symbols [default=no]
+  --disable-tests         do not compile and enable unit tests [default=yes]
+  --disable-examples      do not compile example programs [default=yes]
+  --disable-pch           do not use precompiled headers (if buggy compiler)
+  --disable-silent-rules  print every compilation statement as executed
+  --enable-system-debug   put .debug files in global GDB debug dir
+                          [default=yes if prefix=/usr, no otherwise]
+  --enable-parallel       process in parallel using MPI [default=no]
+  --enable-openmp         activate experimental support for OpenMP
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --enable-underscoring   assume Fortran routines have _ suffix [default=no]
+  --enable-ninja          use Ninja build generator [default=no]
+                          (automatically implies --enable-underscoring)
+  --config-cache          Reuse build configuration cache from a previous run
+
+Optional Packages:
+  --with-ug=PATH          use the UG libraries from a specified location
+  --with-alugrid=PATH     use the ALUGrid library from a specified location
+  --with-metis=PATH       use the METIS graph partitioning library from a specified location
+  --with-boost=PATH       use Boost library from a specified location
+  --with-dune=PATH        specify parent of all DUNE modules not specified
+  --with-dune-MODULE=PATH use given DUNE module from a specified location
+  --with-opm=PATH         specify parent of all OPM modules not specified
+  --with-opm-MODULE=PATH  use given OPM module from a specified location
+  --with-superlu=PATH     user defined path to SuperLU library
+  --with-umfpack=PATH     use UMFPACK/SuiteSparse from a specified location
+  --with-ert=PATH         Use ERT libraries
+  --with-zoltan=PATH      Use ZOLTAN libraries
+  --with-tinyxml=PATH     use TinyXML library from a specified location
+                          (Note: if not found, then a bundled library will
+                           be used)
+  --with-cmake=PROGRAM    use this program instead of \`cmake' to configure
+  --with-buildname=TEXT   description passed to the CDash configuration
+  --with-site=TEXT        site passed to the CDash configuration
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CPP         C preprocessor
+  CXX         C++ compiler command
+  CXXFLAGS    C++ compiler flags
+  CXXCPP      C++ preprocessor
+  F77         Fortran 77 compiler command
+  FFLAGS      Fortran 77 compiler flags
+  FC          Fortran compiler command
+  FCFLAGS     Fortran compiler flags
+  CMAKE_COMMAND  Executable used to run cmake scripts
+
+Use these variables to override the choices made by \`configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+EOF
+}
+
+# report an error regarding the arguments
+invalid_arg () {
+  cat <<EOF
+configure: error: unrecognized option: \`$1'
+Try \`$0 --help' for more information
+EOF
+}
+
+# notify the user that this argument is not known
+unknown_arg () {
+  cat <<EOF
+configure: warning: unrecognized option: \`$1'
+EOF
+}
+
+# warn only if option checking is enabled
+invalid_opt () {
+  if [ "${option_check}" = "yes" ]; then
+    unknown_arg "$@"
+  fi
+}
+
+# default values
+prefix=/usr/local
+#c_compiler=" -DCMAKE_C_COMPILER=cc"
+c_compiler=
+c_opts=
+#cxx_compiler=" -DCMAKE_CXX_COMPILER=c++"
+cxx_compiler=
+cxx_opts=
+#fort_compiler=" -DCMAKE_Fortran_COMPILER=fc"
+fort_compiler=
+fort_opts=
+#buildtype=" -DCMAKE_BUILD_TYPE=Debug"
+buildtype=
+#pch_use=" -DPRECOMPILE_HEADERS:BOOL=ON"
+pch_use=
+#use_openmp=" -DUSE_OPENMP=OFF"
+use_openmp=
+use_mpi=
+#silent_rules=" -DCMAKE_VERBOSE_MAKEFILE=OFF"
+silent_rules=
+#debug_loc=" -DSYSTEM_DEBUG=OFF"
+debug_loc=
+#use_lto=" -DWHOLE_PROG_OPTIM=OFF"
+use_lto=
+#strip_debug=" -DSTRIP_DEBUGGING_SYMBOLS=OFF"
+strip_debug=
+#use_runpath=" -DUSE_RUNPATH=OFF"
+use_runpath=
+#use_tests=" -DBUILD_TESTING=ON"
+use_tests=
+#use_samples=" -DBUILD_EXAMPLES=ON"
+use_samples=
+#use_ninja="-G\"Unix Makefiles\" "
+use_ninja=
+#use_underscoring=" -DUSE_UNDERSCORING=OFF"
+use_underscoring=
+# boost_root=""
+boost_root=
+boost_libdir=
+boost_opts=
+# configuration that is passed on to CTest/CDash
+buildname=
+site=
+# if set, this prevents the previous CMake cache from being deleted
+config_cache=
+
+# default is to warn for unknown options, but this can be disabled
+option_check=yes
+
+# this variable will get feature options
+FEATURES=
+
+# this array will get all variable assignments from command-line
+VARS=()
+
+# command that launches cmake; look for 2.8 if available
+if [ "${CMAKE_COMMAND}" = "" ]; then
+  if [ -x "$(command -v cmake28)" ]; then
+    CMAKE_COMMAND=cmake28
+  else
+    CMAKE_COMMAND=cmake
+  fi
+fi
+
+# helper routine
+uppercase () {
+  echo "$@" | tr "a-z-" "A-Z_"
+}
+
+for OPT in "$@"; do
+  case "$OPT" in
+    --*)
+      OPTARG=${OPT#--}
+      # OPTARG now contains everything after double dashes
+      case "${OPTARG}" in
+        config-cache|cache-file=*)
+          # prevent the previous CMake cache from being deleted. The
+          # second option is only here for Dune/autotools compatibility
+          config_cache="1"
+          ;;
+        src-dir=*)
+          # allow the user to use these build macros for another
+          # project (so source-dir is not relative to us)
+          srcdir=${OPTARG#*=}
+          ;;
+        prefix=*)
+          # remove prefix consisting of everything up to equal sign
+          prefix=${OPTARG#*=}
+          ;;
+        help)
+          usage
+          exit 0
+          ;;
+        with-*)
+          # get the name of the package; everything before equal sign
+          pkgname=${OPTARG%=*}
+          pkgname=${pkgname#with-}
+          # get the location of the package; everyhing after equal sign
+          test -n "${OPTARG#with-${pkgname}}" && pkgloc=${OPTARG#*=} || pkgloc=""
+          # the parameter to this option is an executable program, so
+          # skip the directory test in that case. if we match any of
+          # these special options, then stop further processing (the
+          # argument is not a directory anyway)
+          case "${pkgname}" in
+            cmake)
+              CMAKE_COMMAND="${pkgloc}"
+              continue
+              ;;
+            buildname)
+              buildname=" -DBUILDNAME=\"${pkgloc}\""
+              continue
+              ;;
+            site)
+              site=" -DSITE=\"${pkgloc}\""
+              continue
+              ;;
+          esac
+          # tilde expansion; quote safely before running eval on it
+          eval pkgloc=$(printf "%q" "${pkgloc}")
+          # expand to full path since CMake changes to source directory (!)
+          # this also normalize the path name wrt. not having a trailing slash
+          test -d "${pkgloc}" && pkgloc=$(sh -c "cd \"${pkgloc}\"; pwd")
+          # special aliases
+          case "${pkgname}" in
+            umfpack)
+              pkgname="SuiteSparse"
+              ;;
+            tinyxml)
+              pkgname="TinyXML"
+              ;;
+          esac
+          # packages need different suffix for their root (sic)
+          case "${pkgname}" in
+            pch)
+              pch_use=" -DPRECOMPILE_HEADERS:BOOL=ON"
+              rootvar=""
+              ;;
+            mpi         |\
+            mpi-prefix)
+              # specifying path implies use of package
+              use_mpi=" -DUSE_MPI=ON"
+              # only set prefix if specified, i.e. setting doubles as flag
+              test -n "${pkgloc}" && rootvar="_MPI_PREFIX_PATH" || rootvar=""
+              ;;
+            boost)
+              # special handling of this package, see further below
+              boost_root="${pkgloc}"
+              rootvar=""
+              ;;
+            boost-libdir)
+              boost_libdir="${pkgloc}"
+              rootvar=""
+              ;;
+            alugrid     |\
+            eigen3      |\
+            ert         |\
+            metis       |\
+            superlu     |\
+            SuiteSparse |\
+            TinyXML     |\
+            ug          |\
+            opm         |\
+            opm-*       |\
+            dune        |\
+            dune-*      |\
+            zoltan      |\
+            zlib)
+              rootvar="$(uppercase ${pkgname})_ROOT"
+              rootvar="${rootvar/-/_}"
+              ;;
+            *)
+              invalid_opt --with-${pkgname}
+              rootvar=""
+              ;;
+          esac
+          # add this to the list of existing features
+          test -n "${rootvar}" && \
+          FEATURES="${FEATURES} \"-D${rootvar}=${pkgloc}\""
+          ;;
+        without-* | \
+        disable-*)
+          # get the name of the package
+          pkgname=$OPTARG
+          pkgname=${pkgname#disable-}
+          pkgname=${pkgname#without-}
+          # casing is of course different
+          case "${pkgname}" in
+            option-checking)
+              option_check=no
+              # special flag: don't disable any particular package
+              pkgname=""
+              ;;
+            debug)
+              buildtype=" -DCMAKE_BUILD_TYPE=Release"
+              # special flag: don't disable any particular package
+              pkgname=""
+              ;;
+            pch)
+              pch_use=" -DPRECOMPILE_HEADERS:BOOL=OFF"
+              pkgname=""
+              ;;
+            runpath)
+              use_runpath=" -DUSE_RUNPATH=OFF"
+              pkgname=""
+              ;;
+            silent-rules)
+              silent_rules=" -DCMAKE_VERBOSE_MAKEFILE=ON"
+              pkgname=""
+              ;;
+            system-debug)
+              debug_loc=" -DSYSTEM_DEBUG=OFF"
+              pkgname=""
+              ;;
+            wpo  |\
+            lto  )
+              use_lto=" -DWHOLE_PROG_OPTIM=OFF"
+              pkgname=""
+              ;;
+            strip-debug  )
+              strip_debug=" -DSTRIP_DEBUGGING_SYMBOLS=OFF"
+              pkgname=""
+              ;;
+            openmp)
+              use_openmp=" -DUSE_OPENMP=OFF"
+              pkgname=""
+              ;;
+            mpi  | \
+            parallel)
+              use_mpi=" -DUSE_MPI=OFF"
+              pkgname=""
+              ;;
+            tests)
+              use_tests=" -DBUILD_TESTING=OFF"
+              pkgname=""
+              ;;
+            examples)
+              use_samples=" -DBUILD_EXAMPLES=OFF"
+              pkgname=""
+              ;;
+            ninja)
+              # just for symmetry with the --enable-ninja option
+              use_ninja=""
+              pkgname=""
+              ;;
+            ert  |\
+            superlu)
+              pkgname="$(uppercase ${pkgname})"
+              ;;
+            openmp)
+              pkgname="OpenMP"
+              ;;
+            gxx11check)
+              pkgname="CXX11Features"
+              ;;
+            umfpack)
+              pkgname="SuiteSparse"
+              ;;
+            tinyxml)
+              pkgname="TinyXML"
+              ;;
+            *)
+              invalid_opt --disable-${pkgname}
+              pkgname=""
+              ;;
+          esac
+          # only disable packages if the flag refers to a proper one
+          test -n "${pkgname}" && \
+          FEATURES="${FEATURES} -DCMAKE_DISABLE_FIND_PACKAGE_${pkgname}=TRUE"
+          ;;
+        enable-*)
+          # what kind of library are we building; shared or static?
+          kind=${OPTARG#enable-}
+          case "${kind}" in
+            system-debug)
+              debug_loc=" -DSYSTEM_DEBUG=ON"
+              # special flag; don't set shared/static
+              shared=""
+              ;;
+            openmp)
+              use_openmp=" -DUSE_OPENMP=ON"
+              # special flag; don't set shared/static
+              shared=""
+              ;;
+            mpi  | \
+            parallel)
+              use_mpi=" -DUSE_MPI=ON"
+              # special flag; don't set shared/static
+              shared=""
+              ;;
+            debug)
+              buildtype=" -DCMAKE_BUILD_TYPE=Debug"
+              shared=""
+              ;;
+            pch)
+              pch_use=" -DPRECOMPILE_HEADERS:BOOL=ON"
+              shared=""
+              ;;
+            runpath)
+              use_runpath=" -DUSE_RUNPATH=ON"
+              shared=""
+              ;;              
+            lto)
+              use_lto=" -DWHOLE_PROG_OPTIM=ON"
+              shared=""
+              ;;
+            strip-debug  )
+              strip_debug=" -DSTRIP_DEBUGGING_SYMBOLS=ON"
+              pkgname=""
+              ;;
+            tests)
+              use_tests=" -DBUILD_TESTING=ON"
+              pkgname=""
+              ;;
+            examples)
+              use_samples=" -DBUILD_EXAMPLES=ON"
+              pkgname=""
+              ;;
+            underscoring)
+              use_underscoring=" -DUSE_UNDERSCORING=ON"
+              pkgname=""
+              ;;
+            ninja)
+              # Ninja doesn't support using the Fortran compiler, so
+              # we'll have to resort to making this assumption
+              use_underscoring=" -DUSE_UNDERSCORING=ON"
+              use_ninja="-GNinja "
+              pkgname=""
+              ;;
+            # this flag is just for compatibility with the deprecation
+            # flag in DUNE, so we can build without warnings
+            fieldvector-size-is-method)
+              shared=""
+              ;;              
+            shared)
+              shared="ON"
+              ;;
+            static)
+              shared="OFF"
+              ;;
+            *)
+              invalid_opt "--enable-${kind}"
+              shared=""
+              ;;
+          esac
+          test -n "${shared}" && \
+          FEATURES="${FEATURES} -DBUILD_SHARED_LIBS:BOOL=${shared}"
+          # once we have added this, reset so we don't add again for next opt
+          shared=""
+          ;;
+        *)
+          # remove everything *after* the equal sign
+          arg=${OPTARG%=*}
+          invalid_arg "--$arg"
+          exit 1
+          ;;
+      esac
+      ;;
+    [A-Za-z0-9_]*=*)
+      # collect for further processing later
+      VARS+=("$OPT")
+      ;;
+    *)
+      invalid_arg "$OPT"
+      exit 1
+      ;;
+  esac
+done
+# remove all arguments processed by getopts
+shift $((OPTIND-1))
+
+# special handling of Boost: if --with-boost-libdir has been used,
+# then the --with-boost turns into specifying the header directory
+# and not the search root. this mirrors the functionality in the
+# Autotools ax_boost_base.m4. necessary because FindBoost in CMake
+# uses two different variables if you want to specify them separately
+if [ -n "${boost_libdir}" ]; then
+    boost_opts=" -DBOOST_LIBRARYDIR=\"${boost_libdir}\""
+    if [ -n "${boost_root}" ]; then
+        boost_opts="${boost_opts} -DBOOST_INCLUDEDIR=\"${boost_root}\""
+    fi
+else
+    if [ -n "${boost_root}" ]; then
+        boost_opts=" -DBOOST_ROOT=\"${boost_root}\""
+    else
+        boost_opts=""
+    fi
+fi
+
+# notice the usage of a quoted array: each element will be returned
+# even with spaces.
+for a in "${VARS[@]}"; do
+  case "$a" in
+    ACLOCAL_*=*)
+      # remove Autotools-specific variables. 
+      ;;
+    CC=*)
+      # special processing for compiler options
+      a=${a#CC=}
+      [ -x "$(command -v "$a")" ] && a=$(command -v "$a")
+      c_compiler=" -DCMAKE_C_COMPILER=\"${a/\"/\\\"}\""
+      ;;
+    CXX=*)
+      a=${a#CXX=}
+      [ -x "$(command -v "$a")" ] && a=$(command -v "$a")
+      cxx_compiler=" -DCMAKE_CXX_COMPILER=\"${a/\"/\\\"}\""
+      ;;
+    CFLAGS=*)
+      a=${a#CFLAGS=}
+      c_opts=" -DCMAKE_BUILD_TYPE=Custom -DCMAKE_C_FLAGS=\"${a/\"/\\\"}\""
+      ;;
+    CXXFLAGS=*)
+      a=${a#CXXFLAGS=}
+      cxx_opts=" -DCMAKE_BUILD_TYPE=Custom -DCMAKE_CXX_FLAGS=\"${a/\"/\\\"}\""
+      ;;
+    FC=*)
+      a=${a#FC=}
+      [ -x "$(command -v "$a")" ] && a=$(command -v "$a")
+      fort_compiler=" -DCMAKE_Fortran_COMPILER=\"${a/\"/\\\"}\""
+      ;;
+    FFLAGS=*)
+      a=${a#FFLAGS=}
+      fort_opts=" -DCMAKE_BUILD_TYPE=Custom -DCMAKE_Fortran_FLAGS=\"${a/\"/\\\"}\""
+      ;;
+    *)
+      ENVVARS="$ENVVARS \"${a/\"/\\\"}\""
+      ;;
+  esac
+done
+
+# only wrap in env command if any variable were actually passed
+[ -n "${ENVVARS}" ] && ENVVARS="env ${ENVVARS} "
+
+# delete the previous 'CMakeFiles' directory. this prevents an endless
+# loop if variables that require a full regeneration of the cache are
+# set (most notably 'CXX' and 'CXX_FLAGS').
+# For more details, see http://www.cmake.org/Bug/view.php?id=14119
+if test "$config_cache" = ""; then
+    echo "--- deleting previous CMake files ---"
+    rm -rf CMakeFiles
+    rm -f CMakeCache.txt
+elif test "$c_compiler$c_opts$cxx_compiler$cxx_opts$fort_compiler$fort_opts" != ""; then
+    echo "--- WARNING '--config-cache' option specified but a compiler was set"
+    echo "--- from the command line. This may lead to an infinite loop!"
+fi
+
+# pass everything on to CMake
+CMDLINE="${ENVVARS}${CMAKE_COMMAND} \"${srcdir}\" ${use_ninja}\"-DCMAKE_INSTALL_PREFIX=$prefix\" -DSIBLING_SEARCH=OFF${buildtype}${pch_use}${silent_rules}${debug_loc}${use_openmp}${use_mpi}${use_lto}${strip_debug}${use_runpath}${use_tests}${use_samples}${use_underscoring}${c_compiler}${c_opts}${cxx_compiler}${cxx_opts}${fort_compiler}${fort_opts}${boost_opts}${buildname}${site} ${FEATURES}"
+echo --- calling CMake ---
+echo "${CMDLINE}"
+eval exec "${CMDLINE}"

cmake/Templates/opm-project-config.cmake.in

@@ -21,15 +21,14 @@
 
 # Prevent multiple inclusions
 if(NOT @opm-project_NAME@_FOUND)
+
   # propagate these properties from one build system to the other
-  set (@opm-project_NAME@_PREFIX "@DUNE_PREFIX@")
   set (@opm-project_NAME@_VERSION "@opm-project_VERSION@")
   set (@opm-project_NAME@_DEFINITIONS "@opm-project_DEFINITIONS@")
   set (@opm-project_NAME@_INCLUDE_DIRS "@opm-project_INCLUDE_DIRS@")
-  set (@opm-project_NAME@_LIBRARY_DIRS "@opm-project_LIBRARY_DIRS@" "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
+  set (@opm-project_NAME@_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
   set (@opm-project_NAME@_LINKER_FLAGS "@opm-project_LINKER_FLAGS@")
   set (@opm-project_NAME@_CONFIG_VARS "@opm-project_CONFIG_VARS@")
-  set (HAVE_@opm-project_NAME_UC@ 1)
 
   # libraries come from the build tree where this file was generated
   set (@opm-project_NAME@_LIBRARY "@opm-project_LIBRARY@")
@@ -40,10 +39,8 @@ if(NOT @opm-project_NAME@_FOUND)
   if (NOT "@opm-project_TARGET@" STREQUAL "")
     # add the library as a target, so that other things in the project including
     # this file may depend on it and get rebuild if this library changes.
-    if(NOT TARGET @opm-project_TARGET@)
-      get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
-      include("${_dir}/@opm-project_NAME@-targets.cmake")
-    endif()
+    add_library (@opm-project_TARGET@ UNKNOWN IMPORTED)
+    set_property (TARGET @opm-project_TARGET@ PROPERTY IMPORTED_LOCATION "${@opm-project_NAME@_LIBRARY}")
   endif (NOT "@opm-project_TARGET@" STREQUAL "")
 
   # ensure that we build with support for C++11 to preserve ABI
@@ -71,12 +68,6 @@ if(NOT @opm-project_NAME@_FOUND)
 
   # this is the contents of config.h as far as our probes can tell:
 
-  # extra code from variable OPM_PROJECT_EXTRA_CODE
+  # extra code
   @OPM_PROJECT_EXTRA_CODE@
-  # end extra code
-
-  # This call is at the bottom as we need to include
-  # the OpmPackage Macros.
-  set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" @PREREQ_LOCATION@)
-  include(@opm-project_NAME@-prereqs)
 endif()

configure

@@ -0,0 +1,42 @@
+#!/bin/sh
+# this file is supposed to be located in the source directory
+src_dir=$(dirname $0)
+
+# scan the arguments and set this if build macros could be specified
+mod_dir=
+for OPT in "$@"; do
+    case "$OPT" in
+        --with-opm-common=*)
+            # remove everything before equal sign and assign the rest
+            mod_dir=${OPT#*=}
+            # tilde expansion; note that doing eval may have side effects
+            mod_dir=$(eval echo $mod_dir)
+            # absolute path
+            [ -d "$mod_dir" ] && mod_dir=$(cd $mod_dir ; pwd)
+            ;;
+    esac
+done
+
+# special work around the fact that dunecontrol does not specify
+# --with-$MODULE for the module it attempts to build
+ADDITIONAL_PARAMS=""
+if test -z "$mod_dir"; then
+    ADDITIONAL_PARAMS="--with-opm-common=\"$(pwd)\""
+fi
+
+# if it isn't specified, the look around in other known places
+conf_file=cmake/Scripts/configure
+if [ -z "$mod_dir" ]; then
+    if [ -r "$src_dir/$conf_file" ]; then
+        mod_dir="$src_dir"
+    fi
+fi
+
+# terminate with error message here if the module directory is not found
+if [ ! -r "$mod_dir/$conf_file" ]; then
+    echo Build macros not located in \"$mod_dir\", use --with-opm-common= to specify! 1>&2
+    exit 1
+fi
+
+# forward to the corresponding script in the cmake/Scripts/ directory
+exec "$mod_dir/$conf_file" --src-dir="$src_dir" "$@" $ADDITIONAL_PARAMS

debian/changelog

@@ -1,4 +1,4 @@
-opm-common (2015.10-1~trusty) trusty; urgency=medium
+opm-common (2017.10-rfinal-1~xenial) xenial; urgency=medium
 
   * New release
 

debian/control

@@ -4,9 +4,7 @@ Maintainer: Arne Morten Kvarving <arne.morten.kvarving@sintef.no>
 Build-Depends: build-essential, debhelper (>= 9),
                pkg-config, cmake, git, libtool, doxygen,
                texlive-latex-extra, texlive-latex-recommended,
-               ghostscript, libboost-system-dev, libboost-test-dev,
-               libecl-dev, libboost-regex-dev, libboost-filesystem-dev,
-               zlib1g-dev
+               ghostscript, libboost-system-dev, libboost-test-dev
 Standards-Version: 3.9.2
 Section: libs
 Homepage: http://opm-project.org

docs/keywords.txt

@@ -1,336 +0,0 @@
-Keywords is the most important aspect of the ECLIPSE datafile
-parser. 
-
-1. The structure of a keyword
------------------------------
-
-A keyword is the fundamental unit when parsing. Keywords are added to
-the parser by schema definitions. The schema definition of the keywords
-are given as Json files under the opm/share/keywords directory. Json
-can be thought of as a lean alternative to XML, you will find it described
-here: http://www.json.org/
-As part of the build process these keyword definitions are compiled
-to ParserKeyword instances.
-
-
-1.1 Starting a keyword
-----------------------
-The keywords are defined as follows:
-
- 1. The keyword should start in column 0; everything beyond character
-    8 is ignored.
-
- 2. The keyword should start with a alphabet character, subsequent
-    characters should be alphanumeric or in the set [-,_,+].
-
- 3. We think ECLIPSE is case insensitive.
-
-This is cehcked by the static method:
-ParserKeyword::validDeckName(). An important part of the parsing of
-keywords is to detect when the keyword specification is complete. For
-most keywords we can detect that either by a terminating '/' or the
-keywords have a predefined size, but for some odd keywords we can not
-reliably detect the end-of-keyword condition and instead we terminate
-keyword1 when we find a string which corresponds to the start of a new
-keyword. Examples of such oddball keywords include: VFPPROD and
-VFPINJ.
-
-
-1.2 Records
------------
-
-The data content of a keyword comes as a collection of
-records. Records are a collection of 'data', terminated by a '/'. Here
-are three examples of records:
-
-   'METRES'  /
-
-   1  'OFF'  100  '*'  24.0  /
-
-   0.26 0.27 0.26 0.78
-   0.82 0.66 0.27 0.78
-   0.76 0.56 0.23 0.67   /
-
-From these examples we see that:
-
-  1. One record can contain a mix of integer, float and string values.
-  2. Records typically correspond to one line in the data-file, but
-     that is purely convention; the records can be sprinkled with
-     newlines.
-  3. Each record is terminated with a '/'
-
-
-1.3 How many records in a keyword
----------------------------------
-
-One of the first structural elements which must be configured into the
-the parser keywords is the number of records in the different
-keywords, this is closely related to how the keyboard is
-terminated. Here comes some typical examples of keywords:
-
-
-  GRID
-
-
-  WCONHIST
-    ... /
-    ... /
-    ... /
-  /
-
-                ---\  
-  EQLDIMS          |
-    ....   /       |  
-                   |
-  EQUIL            |
-    .... /         |
-    .... /         |
-                ---/
-
-  VFPPROD
-    A ..   /
-    B...   /
-    ....   /
-    ....   /
-
-
-  PVGO
-   /
-   /
-  
-
-In the list above here the GRID keyword has zero records, i.e. no data
-at all. The WCONHIST keyword has three records of data, the EQLDIMS
-keyword has one record, the EQUIL keyword has two records and finally
-the VFPPROD keyword has four records. The number of records, or how to
-infer it, must be configured with the "size" attribute in the JSON
-configuration. When it comes to the number of records and termination
-we currently have five different categories:
-
-  1. Keywords with a fixed number of records. Both the GRID keyword
-     and the EQLDIMS keyword have a fixed number of records, zero and
-     one respectively. These keywords are therefor not explicitly
-     terminated in any way, and the "size" attribute has the numerical
-     explicitly:
-
-       {"name" : "EQLDIMS" , "size" : 1 , ....}
-       {"name" : "GRID" , "size" : 0, .... }
-
-
-  2. Keywords with a variable number of records like the
-     WCONHIST. Becase the number of records is not known in advance
-     this keyword must be explicitly terminated with a '/'. This is
-     the most common configuration and for keywords of this type it is
-     not necessary to specify a size attribute at all:
-
-       {"name" : "WCONHIST" , .... }  
-
-
-  3. Keywords where the number of records is inferred from the content
-     of another keyword; this is the case with EQUIL which reads the
-     number of records from the xxx item of the EQLDIMS keyword. Since
-     the number of records is known in advance (indirectly through the
-     EQLDIMS keyword) the EQUIL keyword is not explicitly terminated
-     with a '/'. In the json file this is specified with the "size"
-     attribute being an object containing the name and item of keyword
-     which should be consulted to infer the size; so for the EQUIL
-     keyword the size attribute looks like:
-
-       {"name" : "EQUIL" ,
-          "size" : {"keyword" : "EQLDIMS" , "item" : "NTEQUL"} , ...
-
-     When parsing the EQUIL keyword the parser will consult the
-     already parsed content of the 'EQLDIMS' keyword (i.e. a
-     DeckKeyword instance) and get the numerical value of the 'NTEQUL'
-     item.
-
-
-  4. For some keywords the number of records should be calculated
-     run-time based based on the content of the first records in the
-     keyword - this at least applies to VFPPROD and VFPINJ. Since the
-     size of the keyword is deterministic - given the first few
-     records - the keyword is not slash terminated.
-
-     To infer the number of records in the keyword based on an
-     internal calculation is not supported, hence for these keywords
-     size is given as unkown, and the keywords are terminated when the
-     next valid keyword is found:
-
-        {"name" : "VFPPROD" , "size" : "UNKNOWN", ....
-     
-
-
-  5. Tables PVTG and PVTO: The two tables PVTG and PVTO are special
-     cased. The special casing should probably be removed, and the
-     "size" : "UNKNOWN" could be used for these two keyword.
-
-
-
-
-1.4 The content of a record: items
-----------------------------------
-
-A record consist of one or several items. An item can consist of one
-or several values from the record, for items with more than one value
-it is not possible to specify the exact number of values - the item
-will just consume the remaining values in the input stream. An item
-has a name, a data type and optionally a default value. For instance
-the WCONHIST keyword has the the following items specification:
-
-     "items":
-      [{"name" : "WELL"         , "value_type" : "STRING"},
-       {"name" : "STATUS"       , "value_type" : "STRING" , "default" : "OPEN"},
-       {"name" : "CMODE"        , "value_type" : "STRING"},
-       {"name" : "ORAT"         , "value_type" : "DOUBLE",  "default" : 0.0, "dimension" : "LiquidSurfaceVolume/Time"},
-       {"name" : "WRAT"         , "value_type" : "DOUBLE" , "default" : 0.0, "dimension" : "LiquidSurfaceVolume/Time"},
-       {"name" : "GRAT"         , "value_type" : "DOUBLE" , "default" : 0.0, "dimension" : "GasSurfaceVolume/Time"},
-       {"name" : "VFPTable"     , "value_type" : "INT"   , "default" : 0.0 , "comment":"The default is a state variable"},
-       {"name" : "Lift"         , "value_type" : "DOUBLE" , "default" : 0.0 , "comment":"The default is a state variable"},
-       {"name" : "THP"          , "value_type" : "DOUBLE" , "default" : 0.0 , "dimension" : "Pressure"},
-       {"name" : "BHP"          , "value_type" : "DOUBLE" , "default" : 0.0 ,"dimension" : "Pressure"},
-       {"name" : "NGLRAT"       , "value_type" : "DOUBLE" , "default" : 0.0 ,"dimension" : "LiquidSurfaceVolume/Time"}]}
-
-Here we can see the following:
-
- 1. The items can be of types string, integer and float, the type is
-    specified with the "value_type" attribute which must equal
-    "STRING", "DOUBLE" or "INT".
-
- 2. You can optionally specify a default value, see the discussion of
-    the parsing workflow below for the treatment of defaults.
-
- 3. For items of type double you can specify a dimension, see XXXX for
-    the available dimensions. For quantities with a dimension the
-    parser will convert to SI units, and the DeckDoubleItem class has
-    a getSIDouble() and getRawDouble() method.
-
-
-Items consuming the rest of the record
---------------------------------------
-
-Most of the items will consume exactly one value from the input deck,
-but it is also possible that the last item consumes the remaining
-items in the input deck, these typically correspond to table keywords
-or lists of memnonics. In the input deck the PVTG keyword will
-typically appear like this:
-
-PVTG
-200   0.15  0.15   10
-      0.20  0.20   12
-      0.25  0.20   15  /
-250   0.05  0.05   20
-      0.15  0.10   40  /
-...
-     
-In the manual this is described as two tables with three columns, one
-with three rows and one with two rows. The leading values of 200 and
-250 are the pressure values where the two tables apply. The visual
-formatting in the deck, and also the written desciption in the manual,
-strongly hints at a table structure - however from a parsing point of
-view this corresponds to just two records of different length. Both
-records start with a pressure value, and then follows 3n consecutive
-values. The item configuration of PVTG looks like this:
-
-     "items" : [
-         {"name":"GAS_PRESSURE", "value_type" : "DOUBLE", "dimension":"Pressure" },
-         {"name":"DATA", "size_type" : "ALL" , "value_type":"DOUBLE" ,
-                 "dimension" : ["OilDissolutionFactor","OilDissolutionFactor","Viscosity"]}
-      ]
-
-I.e. first we consume one value from the input deck and assign it to
-the GAS_PRESSURE item, then the DATA item has "size_type" : "ALL" -
-meaning that this item will consume the the rest of the values in the
-input record. Also observe that for the "DATA" item the dimension is a
-vector of three elements, when converting to SI the dimension applied
-to element i is given as:
-
-   dim[i] = dimension[i % 3]
-
-In addition to tables the grid property keywords use items which
-consume the rest of the record. For instance the PORO keyword will
-typcially look like this in the input deck:
-
-PORO
-0.14 0.15 0.0 0.10
-0.16 0.25 0.1 0.11
-0.14 0.15 0.0 0.09
-...
-0.21 0.07 0.1 0.13
-/
-
-From a parsing point of view this is one single record; which contains
-one item consuming all of the values in the input deck. In the
-configuration this could have been configured as:
-
-   "items" : [{"name"       : "DATA",
-               "value_type" : "DOUBLE" ,
-               "size_type"  : "ALL" ,
-               "default"    : 0 ,
-               "dimension"  : "1"}]                                                                                                                                                                                                                                                                                                                  
-
-However, since keywords containing large data arrays, like e.g. COORD
-and PERMX are quite common a shortcut has been created for such
-keywords, for instance the PORO keyword is configures as:
-
-   {"name" : "PORO" , "sections" : ["GRID"],
-      "data" : {"value_type" : "DOUBLE" , "default" : 0 , "dimension":"1"}}
-
-i.e. the "data" attribute is used as shorthand to configure a keyword
-with one record and one item which consumes all the data of the input
-deck.
-
-
-Multirecord keyword configuration
----------------------------------
-
-
-Units and dimensions
---------------------
-
-The values given in the input dataset are generally dimensionfull, and
-before the simulator can start we must convert to internal SI values
-based on the unit system used in the input deck. In the input deck the
-different physical quantities are generally expressed with
-per-quantity units. The unit system is *not* based on selecting a unit
-for the fundamental dimensions length, mass and time and then deriving
-composite units based on the dimension of the composite quantity. As a
-consequence the list of dimensions supported by the parser is long,
-and growing. The current list can be found in the source file:
-
-   opm/parser/eclipse/Units/UnitSystem.cpp
-
-
-
-Default values
---------------
-
-
-
-
-Classes:
---------
-
-The library contains classes along two dimensions:
-
-   +----------------+     +----------------+     +----------------+ 
-   | Parser         |     | RawDeck        |     | Deck           | 
-   +----------------+     +----------------+     +----------------+ 
-  		       		      	      		    
-   +----------------+     +----------------+     +----------------+ 
-   | ParserKeyword  |     | Rawkeyword     |     | DeckKeyword    | 
-   +----------------+     +----------------+     +----------------+ 
-  		       		      	      		    
-   +----------------+     +----------------+     +----------------+ 
-   | ParserRecord   |     | RawRecord      |     | DeckRecord     | 
-   +----------------+     +----------------+     +----------------+ 
-        		             		            		    
-   +----------------+     		         +----------------+ 
-   | ParserItem     |     		         | DeckItem       | 
-   +----------------+     		         +----------------+ 
-  
-
-
-
-
-
-

dune.module

@@ -5,9 +5,8 @@
 
 Module: opm-common
 Description: Open Porous Media Initiative shared infrastructure
-Version: 2018.10-pre
-Label: 2018.10-pre
+Version: 2017.10
+Label: 2017.10
 Maintainer: opm@opm-project.org
 MaintainerName: OPM community
 Url: http://opm-project.org
-Depends: dune-common

examples/opmi.cpp

@@ -1,50 +0,0 @@
-/*
-  Copyright 2013 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <iostream>
-
-#include <opm/parser/eclipse/Parser/Parser.hpp>
-#include <opm/parser/eclipse/Parser/ParseContext.hpp>
-#include <opm/parser/eclipse/Deck/Deck.hpp>
-#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
-#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
-#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
-#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
-
-
-inline void loadDeck( const char * deck_file) {
-    Opm::ParseContext parseContext;
-    Opm::Parser parser;
-
-    std::cout << "Loading deck: " << deck_file << " ..... "; std::cout.flush();
-    auto deck = parser.parseFile(deck_file, parseContext);
-    std::cout << "parse complete - creating EclipseState .... ";  std::cout.flush();
-    Opm::EclipseState state( deck, parseContext );
-    Opm::Schedule schedule( deck, state.getInputGrid(), state.get3DProperties(), state.runspec().phases(), parseContext);
-    Opm::SummaryConfig summary( deck, schedule, state.getTableManager( ), parseContext );
-    std::cout << "complete." << std::endl;
-
-}
-
-
-int main(int argc, char** argv) {
-    for (int iarg = 1; iarg < argc; iarg++)
-        loadDeck( argv[iarg] );
-}
-

examples/opmpack.cpp

@@ -1,108 +0,0 @@
-/*
-  Copyright 2018 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <iostream>
-#include <getopt.h>
-#include <boost/filesystem.hpp>
-
-#include <opm/parser/eclipse/Parser/Parser.hpp>
-#include <opm/parser/eclipse/Parser/ParseContext.hpp>
-#include <opm/parser/eclipse/Parser/InputErrorAction.hpp>
-#include <opm/parser/eclipse/Deck/Deck.hpp>
-
-
-inline void pack_deck( const char * deck_file, std::ostream& os) {
-    Opm::ParseContext parseContext(Opm::InputError::WARN);
-    Opm::Parser parser;
-
-    auto deck = parser.parseFile(deck_file, parseContext);
-    os << deck;
-
-}
-
-
-void print_help_and_exit() {
-    const char * help_text = R"(
-The opmpack program will load a deck, resolve all include
-files and then print it out again on stdout. All comments
-will be stripped and the value types will be validated.
-
-By passing the option -o you can redirect the output to a file
-or a directory.
-
-Print on stdout:
-
-   opmpack  /path/to/case/CASE.DATA
-
-
-Print MY_CASE.DATA in /tmp:
-
-    opmpack -o /tmp /path/to/MY_CASE.DATA
-
-
-Print NEW_CASE in cwd:
-
-    opmpack -o NEW_CASE.DATA path/to/MY_CASE.DATA
-
-
-)";
-    std::cerr << help_text << std::endl;
-    exit(1);
-}
-
-
-int main(int argc, char** argv) {
-    int arg_offset = 1;
-    bool stdout_output = true;
-    const char * coutput_arg;
-
-    while (true) {
-        int c;
-        c = getopt(argc, argv, "o:");
-        if (c == -1)
-            break;
-
-        switch(c) {
-        case 'o':
-            stdout_output = false;
-            coutput_arg = optarg;
-            break;
-        }
-    }
-    arg_offset = optind;
-    if (arg_offset >= argc)
-        print_help_and_exit();
-
-    if (stdout_output)
-        pack_deck(argv[arg_offset], std::cout);
-    else {
-        std::ofstream os;
-        using path = boost::filesystem::path;
-        path input_arg(argv[arg_offset]);
-        path output_arg(coutput_arg);
-        if (boost::filesystem::is_directory(output_arg)) {
-            path output_path = output_arg / input_arg.filename();
-            os.open(output_path.string());
-        } else
-            os.open(output_arg.string());
-
-        pack_deck(argv[arg_offset], os);
-    }
-}
-

examples/test_util/compareECL.cpp

@@ -1,277 +0,0 @@
-/*
-   Copyright 2016 Statoil ASA.
-
-   This file is part of the Open Porous Media project (OPM).
-
-   OPM is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   OPM is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-   */
-
-#include <opm/test_util/EclFilesComparator.hpp>
-#include <opm/common/ErrorMacros.hpp>
-
-#include <ert/util/util.h>
-#include <ert/util/stringlist.h>
-#include <ert/ecl/ecl_endian_flip.h>
-#include <ert/ecl/ecl_file.h>
-
-#include <iostream>
-#include <string>
-#include <getopt.h>
-
-static void printHelp() {
-    std::cout << "\ncompareECL compares ECLIPSE files (restart (.RST), unified restart (.UNRST), initial (.INIT) or .RFT) and gridsizes (from .EGRID or .GRID file) from two simulations.\n"
-        << "The program takes four arguments:\n\n"
-        << "1. Case number 1 (full path without extension)\n"
-        << "2. Case number 2 (full path without extension)\n"
-        << "3. Absolute tolerance\n"
-        << "4. Relative tolerance (between 0 and 1)\n\n"
-        << "In addition, the program takes these options (which must be given before the arguments):\n\n"
-        << "-h Print help and exit.\n"
-        << "-i Execute integration test (regression test is default).\n"
-        << "   The integration test compares SGAS, SWAT and PRESSURE in unified restart files, so this option can not be used in combination with -t.\n"
-        << "-I Same as -i, but throws an exception when the number of keywords in the two cases differ. Can not be used in combination with -t.\n"
-        << "-k Specify specific keyword to compare (capitalized), for example -k PRESSURE.\n"
-        << "-l Only do comparison for the last occurrence. This option is only for the regression test, and can therefore not be used in combination with -i or -I.\n"
-        << "-n Do not throw on errors.\n"
-        << "-p Print keywords in both cases and exit. Can not be used in combination with -P.\n"
-        << "-P Print common and uncommon keywords in both cases and exit. Can not be used in combination with -p.\n"
-        << "-t Specify ECLIPSE filetype to compare (unified restart is default). Can not be used in combination with -i or -I. Different possible arguments are:\n"
-        << "    -t UNRST \t Compare two unified restart files (.UNRST). This the default value, so it is the same as not passing option -t.\n"
-        << "    -t INIT  \t Compare two initial files (.INIT).\n"
-        << "    -t RFT   \t Compare two RFT files (.RFT).\n"
-        << "    -t RST   \t Compare two cases consisting of restart files (.Xnnnn).\n"
-        << "    -t RST1  \t Compare two cases where the first case consists of restart files (.Xnnnn), and the second case consists of a unified restart file (.UNRST).\n"
-        << "    -t RST2  \t Compare two cases where the first case consists of a unified restart file (.UNRST), and the second case consists of restart files (.Xnnnn).\n"
-        << "   Note that when dealing with restart files (.Xnnnn), the program concatenates all of them into one unified restart file, which is used for comparison and stored in the same directory as the restart files.\n"
-        << "   This will overwrite any existing unified restart file in that directory.\n\n"
-        << "Example usage of the program: \n\n"
-        << "compareECL -k PRESSURE <path to first casefile> <path to second casefile> 1e-3 1e-5\n"
-        << "compareECL -t INIT -k PORO <path to first casefile> <path to second casefile> 1e-3 1e-5\n"
-        << "compareECL -i <path to first casefile> <path to second casefile> 0.01 1e-6\n\n"
-        << "Exceptions are thrown (and hence program exits) when deviations are larger than the specified "
-        << "tolerances, or when the number of cells does not match -- either in the grid file or for a "
-        << "specific keyword. Information about the keyword, keyword occurrence (zero based) and cell "
-        << "coordinate is printed when an exception is thrown. For more information about how the cases "
-        << "are compared, see the documentation of the EclFilesComparator class.\n\n";
-}
-
-
-
-void splitBasename(const std::string& basename, std::string& path, std::string& filename) {
-    const size_t lastSlashIndex = basename.find_last_of("/\\");
-    path = basename.substr(0,lastSlashIndex);
-    filename = basename.substr(lastSlashIndex+1);
-}
-
-
-
-// Inspired by the ecl_pack application in the ERT library
-void concatenateRestart(const std::string& basename) {
-    std::string inputPath, inputBase;
-    splitBasename(basename, inputPath, inputBase);
-    stringlist_type* inputFiles = stringlist_alloc_new();
-    const int numFiles = ecl_util_select_filelist(inputPath.c_str(), inputBase.c_str(), ECL_RESTART_FILE, false, inputFiles);
-
-    const char* target_file_name = ecl_util_alloc_filename(inputPath.c_str(), inputBase.c_str(), ECL_UNIFIED_RESTART_FILE, false, -1);
-    fortio_type* target = fortio_open_writer(target_file_name, false, ECL_ENDIAN_FLIP);
-    int dummy;
-    ecl_kw_type* seqnum_kw = ecl_kw_alloc_new("SEQNUM", 1, ECL_INT, &dummy);
-
-    int reportStep = 0;
-    for (int i = 0; i < numFiles; ++i) {
-        ecl_util_get_file_type(stringlist_iget(inputFiles, i), nullptr, &reportStep);
-        ecl_file_type* src_file = ecl_file_open(stringlist_iget(inputFiles, i), 0);
-        ecl_kw_iset_int(seqnum_kw, 0, reportStep);
-        ecl_kw_fwrite(seqnum_kw, target);
-        ecl_file_fwrite_fortio(src_file, target, 0);
-        ecl_file_close(src_file);
-    }
-    fortio_fclose(target);
-    stringlist_free(inputFiles);
-}
-
-//------------------------------------------------//
-
-int main(int argc, char** argv) {
-    // Restart is default
-    ecl_file_enum file_type      = ECL_UNIFIED_RESTART_FILE;
-    // RegressionTest is default
-    bool integrationTest         = false;
-    bool checkNumKeywords        = false;
-    bool onlyLastOccurrence      = false;
-    bool printKeywords           = false;
-    bool printKeywordsDifference = false;
-    bool specificKeyword         = false;
-    bool specificFileType        = false;
-    bool throwOnError            = true;
-    bool volumecheck             = true;
-    char* keyword                = nullptr;
-    char* fileTypeCstr           = nullptr;
-    int c                        = 0;
-
-    while ((c = getopt(argc, argv, "hiIk:lnpPt:V")) != -1) {
-        switch (c) {
-            case 'h':
-                printHelp();
-                return 0;
-            case 'i':
-                integrationTest = true;
-                break;
-            case 'I':
-                integrationTest = true;
-                checkNumKeywords = true;
-                break;
-            case 'n':
-                throwOnError = false;
-                break;
-            case 'k':
-                specificKeyword = true;
-                keyword = optarg;
-                break;
-            case 'l':
-                onlyLastOccurrence = true;
-                break;
-            case 'p':
-                printKeywords = true;
-                break;
-            case 'P':
-                printKeywordsDifference = true;
-                break;
-            case 't':
-                specificFileType = true;
-                fileTypeCstr = optarg;
-                break;
-            case 'V':
-                volumecheck = false;
-                break;
-            case '?':
-                if (optopt == 'k') {
-                    std::cerr << "Option k requires a keyword as argument, see manual (-h) for more information." << std::endl;
-                    return EXIT_FAILURE;
-                }
-                else if (optopt == 't') {
-                    std::cerr << "Option t requires an ECLIPSE filetype as argument, see manual (-h) for more information." << std::endl;
-                    return EXIT_FAILURE;
-                }
-                else {
-                    std::cerr << "Unknown option." << std::endl;
-                    return EXIT_FAILURE;
-                }
-            default:
-                return EXIT_FAILURE;
-        }
-    }
-    int argOffset = optind;
-    if ((printKeywords && printKeywordsDifference) ||
-        (integrationTest && specificFileType)      ||
-        (integrationTest && onlyLastOccurrence)) {
-        std::cerr << "Error: Options given which can not be combined. "
-            << "Please see the manual (-h) for more information." << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    if (argc != argOffset + 4) {
-        std::cerr << "Error: The number of options and arguments given is not correct. "
-            << "Please run compareECL -h to see manual." << std::endl;
-        return EXIT_FAILURE;
-    }
-    std::string basename1 = argv[argOffset];
-    std::string basename2 = argv[argOffset + 1];
-    double absTolerance   = strtod(argv[argOffset + 2], nullptr);
-    double relTolerance   = strtod(argv[argOffset + 3], nullptr);
-
-    if (specificFileType) {
-        std::string fileTypeString(fileTypeCstr);
-        for (auto& ch: fileTypeString) ch = toupper(ch);
-        if (fileTypeString== "UNRST") {} //Do nothing
-        else if (fileTypeString == "RST") {
-            concatenateRestart(basename1);
-            concatenateRestart(basename2);
-        }
-        else if (fileTypeString == "RST1") {
-            concatenateRestart(basename1);
-        }
-        else if (fileTypeString == "RST2") {
-            concatenateRestart(basename2);
-        }
-        else if (fileTypeString == "INIT") {
-            file_type = ECL_INIT_FILE;
-        }
-        else if (fileTypeString == "RFT") {
-            file_type = ECL_RFT_FILE;
-        }
-        else {
-            std::cerr << "Unknown ECLIPSE filetype specified with option -t. Please run compareECL -h to see manual." << std::endl;
-            return EXIT_FAILURE;
-        }
-    }
-    std::cout << "Comparing '" << basename1 << "' to '" << basename2 << "'." << std::endl;
-    try {
-        if (integrationTest) {
-            IntegrationTest comparator(basename1, basename2, absTolerance, relTolerance);
-            if (printKeywords) {
-                comparator.printKeywords();
-                return 0;
-            }
-            if (printKeywordsDifference) {
-                comparator.printKeywordsDifference();
-                return 0;
-            }
-            if (checkNumKeywords) {
-                comparator.equalNumKeywords();
-            }
-            if (specificKeyword) {
-                if (comparator.elementInWhitelist(keyword)) {
-                    comparator.resultsForKeyword(keyword);
-                }
-                else {
-                    std::cerr << "Keyword " << keyword << " is not supported for the integration test. Use SGAS, SWAT or PRESSURE." << std::endl;
-                    return EXIT_FAILURE;
-                }
-            }
-            else {
-                comparator.results();
-            }
-        }
-        else {
-            RegressionTest comparator(file_type, basename1, basename2, absTolerance, relTolerance);
-            comparator.throwOnErrors(throwOnError);
-            if (printKeywords) {
-                comparator.printKeywords();
-                return 0;
-            }
-            if (printKeywordsDifference) {
-                comparator.printKeywordsDifference();
-                return 0;
-            }
-            if (onlyLastOccurrence) {
-                comparator.setOnlyLastOccurrence(true);
-            }
-            if (specificKeyword) {
-                comparator.gridCompare(volumecheck);
-                comparator.resultsForKeyword(keyword);
-            }
-            else {
-                comparator.gridCompare(volumecheck);
-                comparator.results();
-            }
-            if (comparator.getNoErrors() > 0)
-              OPM_THROW(std::runtime_error, comparator.getNoErrors() << " errors encountered in comparisons.");
-        }
-    }
-    catch (const std::exception& e) {
-        std::cerr << "Program threw an exception: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
-    return 0;
-}

examples/test_util/compareSummary.cpp

@@ -1,223 +0,0 @@
-/*
-   Copyright 2016 Statoil ASA.
-
-   This file is part of the Open Porous Media project (OPM).
-
-   OPM is free software: you can redistribute it and/or modify it under the terms
-   of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   OPM is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-   */
-
-
-#include <opm/test_util/summaryRegressionTest.hpp>
-#include <opm/test_util/summaryIntegrationTest.hpp>
-#include <string>
-#include <algorithm>
-#include <stdexcept>
-#include <getopt.h>
-
-void printHelp(){
-    std::cout << "\n\nThe program can handle both unified and non-unified summary files."<< std::endl;
-    std::cout <<"In the case of non-unified summary files all the files must be located in the same directory. Only the basename (full path without extension) is needed as input." << std::endl << std::endl;
-    std::cout << "\nThe program takes four arguments"          << std::endl;
-    std::cout << "1) <path to file1>/<base_name>, basename without extension"            << std::endl;
-    std::cout << "2) <path to file2>/<base_name>, basename without extension"            << std::endl;
-    std::cout << "3) absolute tolerance"                     << std::endl;
-    std::cout << "4) relative tolerance (between 0 and 1)"   << std::endl;
-    std::cout << "The program will only throw an exception when both the absolute and relative tolerance are exceeded." << std::endl;
-    std::cout << "The program is capable of performing both a regression test and an integration test, \nhowever only one type of test at a time. ";
-    std::cout << "By default the program will run a regression test."<< std::endl;
-    std::cout << "\nThe program have command line options:" << std::endl;
-    std::cout << "-h \t\tPrint help message." << std::endl << std::endl;
-    std::cout << "For the regression test: " << std::endl;
-    std::cout << "-r \t\tChoosing regression test (this is default)."<< std::endl;
-    std::cout << "-k keyword \tSpecify a specific keyword to compare, for example - k WOPR:PRODU1."<< std::endl;
-    std::cout << "-p \t\tWill print the keywords of the files." << std::endl;
-    std::cout << "-R \t\tWill allow comparison between a restarted simulation and a normal simulation. The files must end at the same time." << std::endl << std::endl;
-    std::cout << "For the integration test:"<< std::endl;
-    std::cout << "-i \t\tChoosing integration test." << std::endl;
-    std::cout << "-d \t\tThe program will not throw an exception when the volume error ratio exceeds the limit." << std::endl;
-    std::cout << "-g \t\tWill print the vector with the greatest error ratio." << std::endl;
-    std::cout << "-k keyword \tSpecify a specific keyword to compare, for example - k WOPR:PRODU1."<< std::endl;
-    std::cout << "-K \t\tWill not allow different amount of keywords in the two files. Throws an exception if the amount are different." << std::endl;
-    std::cout << "-m mainVar \tWill calculate the error ratio for one main variable. Valid input is WOPR, WWPR, WGPR or WBHP." << std::endl;
-    std::cout << "-n \tDo not throw on errors." << std::endl;
-    std::cout << "-p \t\tWill print the keywords of the files." << std::endl;
-    std::cout << "-P keyword \tWill print the summary vectors of a specified kewyord, for example -P WOPR:B-3H." << std::endl;
-    std::cout << "-s int \t\tSets the number of spikes that are allowed for each keyword, for example: -s 5." << std::endl;
-    std::cout << "-v \t\tFor the rate keywords WOPR, WGPR, WWPR and WBHP. Calculates the error volume of \n\t\tthe two summary files. This is printed to screen." << std::endl;
-    std::cout << "-V keyword \tWill calculate the error rate for a specific keyword." << std::endl << std::endl;
-    std::cout << "Suggested combination of command line options:"<< std::endl;
-    std::cout << " -i -g -m mainVariable, will print the vector which have the greatest error ratio of the main variable of interest.\n"<< std::endl;
-}
-
-//---------------------------------------------------
-
-
-int main (int argc, char ** argv){
-
-    //------------------------------------------------
-    //Defines some constants
-    bool specificKeyword = false;
-    bool allowSpikes = false;
-    bool findVolumeError = false;
-    bool integrationTest = false;
-    bool regressionTest = true;
-    bool allowDifferentAmountOfKeywords = true;
-    bool printKeywords = false;
-    bool printSpecificKeyword = false;
-    bool findVectorWithGreatestErrorRatio = false;
-    bool oneOfTheMainVariables = false;
-    bool throwExceptionForTooGreatErrorRatio = true;
-    bool isRestartFile = false;
-    bool throwOnError = true;
-    const char* keyword  = nullptr;
-    const char* mainVariable = nullptr;
-    int c = 0;
-    int limit = -1;
-    //------------------------------------------------
-
-    //------------------------------------------------
-    //For setting the options selected
-    while ((c = getopt(argc, argv, "dghik:Km:npP:rRs:vV:")) != -1) {
-        switch (c) {
-            case 'd':
-                throwExceptionForTooGreatErrorRatio = false;
-                break;
-            case 'g':
-                findVectorWithGreatestErrorRatio = true;
-                throwExceptionForTooGreatErrorRatio = false;
-                break;
-            case 'h':
-                printHelp();
-                return 0;
-            case 'i':
-                integrationTest = true;
-                regressionTest = false;
-                break;
-            case 'k':
-                specificKeyword = true;
-                keyword = optarg;
-                break;
-            case 'K':
-                allowDifferentAmountOfKeywords = false;
-                break;
-            case 'm':
-                oneOfTheMainVariables = true;
-                mainVariable = optarg;
-                break;
-            case 'n':
-                throwOnError = false;
-                break;
-            case 'p':
-                printKeywords = true;
-                break;
-            case 'P':
-                specificKeyword = true;
-                printSpecificKeyword = true;
-                keyword = optarg;
-                break;
-            case 'r':
-                integrationTest = false;
-                regressionTest = true;
-                break;
-            case 'R':
-                isRestartFile = true;
-                break;
-            case 's':
-                allowSpikes = true;
-                limit = atof(optarg);
-                break;
-            case 'v':
-                findVolumeError = true;
-                break;
-            case 'V':
-                findVolumeError = true;
-                specificKeyword = true;
-                keyword = optarg;
-                break;
-            case '?':
-                if (optopt == 'k' || optopt == 'm' || optopt == 'P'
-                    || optopt == 's' || optopt == 'V') {
-                    std::cout << "Option -"<<optopt<<" requires an keyword." << std::endl;
-                    return EXIT_FAILURE;
-                }
-                else {
-                    std::cout << "Unknown option." << std::endl;
-                    return EXIT_FAILURE;
-                }
-            default:
-                return EXIT_FAILURE;
-        }
-    }
-    //------------------------------------------------
-
-    int argOffset = optind;
-    if (argc != argOffset + 4) {
-        printHelp();
-        return EXIT_FAILURE;
-    }
-    const char * basename1   = argv[argOffset];
-    const char * basename2   = argv[argOffset+1];
-    double absoluteTolerance = strtod(argv[argOffset+2], nullptr);
-    double relativeTolerance = strtod(argv[argOffset+3], nullptr);
-
-    std::cout << "Comparing '" << basename1 << "' to '" << basename2 << "'." << std::endl;
-
-    try {
-        if(regressionTest){
-            RegressionTest compare(basename1,basename2, absoluteTolerance, relativeTolerance);
-            compare.throwOnErrors(throwOnError);
-            if(printKeywords){compare.setPrintKeywords(true);}
-            if(isRestartFile){compare.setIsRestartFile(true);}
-            if(specificKeyword){
-                compare.getRegressionTest(keyword);
-            }
-            else{
-                if(printKeywords){compare.setPrintKeywords(true);}
-                compare.getRegressionTest();
-            }
-        }
-        if(integrationTest){
-            IntegrationTest compare(basename1,basename2, absoluteTolerance, relativeTolerance);
-            compare.throwOnErrors(throwOnError);
-            if(findVectorWithGreatestErrorRatio){compare.setFindVectorWithGreatestErrorRatio(true);}
-            if(allowSpikes){compare.setAllowSpikes(true);}
-            if(oneOfTheMainVariables){
-                compare.setOneOfTheMainVariables(true);
-                std::string str(mainVariable);
-                std::transform(str.begin(), str.end(),str.begin(), ::toupper);
-                if(str == "WOPR" ||str=="WWPR" ||str=="WGPR" || str == "WBHP"){
-                    compare.setMainVariable(str);
-                }else{
-                    throw std::invalid_argument("The input is not a main variable. -m option requires a valid main variable.");
-                }
-            }
-            if(findVolumeError){compare.setFindVolumeError(true);}
-            if(limit != -1){compare.setSpikeLimit(limit);}
-            if(!allowDifferentAmountOfKeywords){compare.setAllowDifferentAmountOfKeywords(false);}
-            if(printKeywords){compare.setPrintKeywords(true);}
-            if(!throwExceptionForTooGreatErrorRatio){compare.setThrowExceptionForTooGreatErrorRatio(false);}
-            if(specificKeyword){
-                if(printSpecificKeyword){compare.setPrintSpecificKeyword(true);}
-                compare.getIntegrationTest(keyword);
-                return 0;
-            }
-            compare.getIntegrationTest();
-        }
-    }
-    catch(const std::exception& e) {
-        std::cerr << "Program threw an exception: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
-    return 0;
-}

external/cjson/README

@@ -1,247 +0,0 @@
-/*
-  Copyright (c) 2009 Dave Gamble
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-Welcome to cJSON.
-
-cJSON aims to be the dumbest possible parser that you can get your job done with.
-It's a single file of C, and a single header file.
-
-JSON is described best here: http://www.json.org/
-It's like XML, but fat-free. You use it to move data around, store things, or just
-generally represent your program's state.
-
-
-First up, how do I build?
-Add cJSON.c to your project, and put cJSON.h somewhere in the header search path.
-For example, to build the test app:
-
-gcc cJSON.c test.c -o test -lm
-./test
-
-
-As a library, cJSON exists to take away as much legwork as it can, but not get in your way.
-As a point of pragmatism (i.e. ignoring the truth), I'm going to say that you can use it
-in one of two modes: Auto and Manual. Let's have a quick run-through.
-
-
-I lifted some JSON from this page: http://www.json.org/fatfree.html
-That page inspired me to write cJSON, which is a parser that tries to share the same
-philosophy as JSON itself. Simple, dumb, out of the way.
-
-Some JSON:
-{
-    "name": "Jack (\"Bee\") Nimble", 
-    "format": {
-        "type":       "rect", 
-        "width":      1920, 
-        "height":     1080, 
-        "interlace":  false, 
-        "frame rate": 24
-    }
-}
-
-Assume that you got this from a file, a webserver, or magic JSON elves, whatever,
-you have a char * to it. Everything is a cJSON struct.
-Get it parsed:
-        cJSON *root = cJSON_Parse(my_json_string);
-
-This is an object. We're in C. We don't have objects. But we do have structs.
-What's the framerate?
-
-        cJSON *format = cJSON_GetObjectItem(root,"format");
-        int framerate = cJSON_GetObjectItem(format,"frame rate")->valueint;
-
-
-Want to change the framerate?
-        cJSON_GetObjectItem(format,"frame rate")->valueint=25;
-        
-Back to disk?
-        char *rendered=cJSON_Print(root);
-
-Finished? Delete the root (this takes care of everything else).
-        cJSON_Delete(root);
-
-That's AUTO mode. If you're going to use Auto mode, you really ought to check pointers
-before you dereference them. If you want to see how you'd build this struct in code?
-        cJSON *root,*fmt;
-        root=cJSON_CreateObject();      
-        cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble"));
-        cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject());
-        cJSON_AddStringToObject(fmt,"type",             "rect");
-        cJSON_AddNumberToObject(fmt,"width",            1920);
-        cJSON_AddNumberToObject(fmt,"height",           1080);
-        cJSON_AddFalseToObject (fmt,"interlace");
-        cJSON_AddNumberToObject(fmt,"frame rate",       24);
-
-Hopefully we can agree that's not a lot of code? There's no overhead, no unnecessary setup.
-Look at test.c for a bunch of nice examples, mostly all ripped off the json.org site, and
-a few from elsewhere.
-
-What about manual mode? First up you need some detail.
-Let's cover how the cJSON objects represent the JSON data.
-cJSON doesn't distinguish arrays from objects in handling; just type.
-Each cJSON has, potentially, a child, siblings, value, a name.
-
-The root object has: Object Type and a Child
-The Child has name "name", with value "Jack ("Bee") Nimble", and a sibling:
-Sibling has type Object, name "format", and a child.
-That child has type String, name "type", value "rect", and a sibling:
-Sibling has type Number, name "width", value 1920, and a sibling:
-Sibling has type Number, name "height", value 1080, and a sibling:
-Sibling hs type False, name "interlace", and a sibling:
-Sibling has type Number, name "frame rate", value 24
-
-Here's the structure:
-typedef struct cJSON {
-        struct cJSON *next,*prev;
-        struct cJSON *child;
-
-        int type;
-
-        char *valuestring;
-        int valueint;
-        double valuedouble;
-
-        char *string;
-} cJSON;
-
-By default all values are 0 unless set by virtue of being meaningful.
-
-next/prev is a doubly linked list of siblings. next takes you to your sibling,
-prev takes you back from your sibling to you.
-Only objects and arrays have a "child", and it's the head of the doubly linked list.
-A "child" entry will have prev==0, but next potentially points on. The last sibling has next=0.
-The type expresses Null/True/False/Number/String/Array/Object, all of which are #defined in
-cJSON.h
-
-A Number has valueint and valuedouble. If you're expecting an int, read valueint, if not read
-valuedouble.
-
-Any entry which is in the linked list which is the child of an object will have a "string"
-which is the "name" of the entry. When I said "name" in the above example, that's "string".
-"string" is the JSON name for the 'variable name' if you will.
-
-Now you can trivially walk the lists, recursively, and parse as you please.
-You can invoke cJSON_Parse to get cJSON to parse for you, and then you can take
-the root object, and traverse the structure (which is, formally, an N-tree),
-and tokenise as you please. If you wanted to build a callback style parser, this is how
-you'd do it (just an example, since these things are very specific):
-
-void parse_and_callback(cJSON *item,const char *prefix)
-{
-        while (item)
-        {
-                char *newprefix=malloc(strlen(prefix)+strlen(item->name)+2);
-                sprintf(newprefix,"%s/%s",prefix,item->name);
-                int dorecurse=callback(newprefix, item->type, item);
-                if (item->child && dorecurse) parse_and_callback(item->child,newprefix);
-                item=item->next;
-                free(newprefix);
-        }
-}
-
-The prefix process will build you a separated list, to simplify your callback handling.
-The 'dorecurse' flag would let the callback decide to handle sub-arrays on it's own, or
-let you invoke it per-item. For the item above, your callback might look like this:
-
-int callback(const char *name,int type,cJSON *item)
-{
-        if (!strcmp(name,"name"))       { /* populate name */ }
-        else if (!strcmp(name,"format/type")    { /* handle "rect" */ }
-        else if (!strcmp(name,"format/width")   { /* 800 */ }
-        else if (!strcmp(name,"format/height")  { /* 600 */ }
-        else if (!strcmp(name,"format/interlace")       { /* false */ }
-        else if (!strcmp(name,"format/frame rate")      { /* 24 */ }
-        return 1;
-}
-
-Alternatively, you might like to parse iteratively.
-You'd use:
-
-void parse_object(cJSON *item)
-{
-        int i; for (i=0;i<cJSON_GetArraySize(item);i++)
-        {
-                cJSON *subitem=cJSON_GetArrayItem(item,i);
-                // handle subitem.      
-        }
-}
-
-Or, for PROPER manual mode:
-
-void parse_object(cJSON *item)
-{
-        cJSON *subitem=item->child;
-        while (subitem)
-        {
-                // handle subitem
-                if (subitem->child) parse_object(subitem->child);
-                
-                subitem=subitem->next;
-        }
-}
-
-Of course, this should look familiar, since this is just a stripped-down version
-of the callback-parser.
-
-This should cover most uses you'll find for parsing. The rest should be possible
-to infer.. and if in doubt, read the source! There's not a lot of it! ;)
-
-
-In terms of constructing JSON data, the example code above is the right way to do it.
-You can, of course, hand your sub-objects to other functions to populate.
-Also, if you find a use for it, you can manually build the objects.
-For instance, suppose you wanted to build an array of objects?
-
-cJSON *objects[24];
-
-cJSON *Create_array_of_anything(cJSON **items,int num)
-{
-        int i;cJSON *prev, *root=cJSON_CreateArray();
-        for (i=0;i<24;i++)
-        {
-                if (!i) root->child=objects[i];
-                else    prev->next=objects[i], objects[i]->prev=prev;
-                prev=objects[i];
-        }
-        return root;
-}
-        
-and simply: Create_array_of_anything(objects,24);
-
-cJSON doesn't make any assumptions about what order you create things in.
-You can attach the objects, as above, and later add children to each
-of those objects.
-
-As soon as you call cJSON_Print, it renders the structure to text.
-
-
-
-The test.c code shows how to handle a bunch of typical cases. If you uncomment
-the code, it'll load, parse and print a bunch of test files, also from json.org,
-which are more complex than I'd care to try and stash into a const char array[].
-
-
-Enjoy cJSON!
-
-
-- Dave Gamble, Aug 2009

external/cjson/README.opm

@@ -1,4 +0,0 @@
-This directory contains the cJSON package downloaded unchanged from:
-http://sourceforge.net/projects/cjson/. The cJSON package is plain C,
-the JsonObject class provides a minimal C++ wrapping of this.
-

external/cjson/cJSON.c

@@ -1,569 +0,0 @@
-/*
-  Copyright (c) 2009 Dave Gamble
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-/* cJSON */
-/* JSON parser in C. */
-
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-#include <stdlib.h>
-#include <float.h>
-#include <limits.h>
-#include <ctype.h>
-#include "cJSON.h"
-
-static const char *ep;
-
-const char *cJSON_GetErrorPtr(void) {return ep;}
-
-static int cJSON_strcasecmp(const char *s1,const char *s2)
-{
-        if (!s1) return (s1==s2)?0:1;if (!s2) return 1;
-        for(; tolower(*s1) == tolower(*s2); ++s1, ++s2) if(*s1 == 0)    return 0;
-        return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);
-}
-
-static void *(*cJSON_malloc)(size_t sz) = malloc;
-static void (*cJSON_free)(void *ptr) = free;
-
-static char* cJSON_strdup(const char* str)
-{
-      size_t len;
-      char* copy;
-
-      len = strlen(str) + 1;
-      if (!(copy = (char*)cJSON_malloc(len))) return 0;
-      memcpy(copy,str,len);
-      return copy;
-}
-
-void cJSON_InitHooks(cJSON_Hooks* hooks)
-{
-    if (!hooks) { /* Reset hooks */
-        cJSON_malloc = malloc;
-        cJSON_free = free;
-        return;
-    }
-
-        cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
-        cJSON_free       = (hooks->free_fn)?hooks->free_fn:free;
-}
-
-/* Internal constructor. */
-static cJSON *cJSON_New_Item(void)
-{
-        cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));
-        if (node) memset(node,0,sizeof(cJSON));
-        return node;
-}
-
-/* Delete a cJSON structure. */
-void cJSON_Delete(cJSON *c)
-{
-        cJSON *next;
-        while (c)
-        {
-                next=c->next;
-                if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);
-                if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);
-                if (c->string) cJSON_free(c->string);
-                cJSON_free(c);
-                c=next;
-        }
-}
-
-/* Parse the input text to generate a number, and populate the result into item. */
-static const char *parse_number(cJSON *item,const char *num)
-{
-        double n=0,sign=1,scale=0;int subscale=0,signsubscale=1;
-
-        /* Could use sscanf for this? */
-        if (*num=='-') sign=-1,num++;   /* Has sign? */
-        if (*num=='0') num++;                   /* is zero */
-        if (*num>='1' && *num<='9')     do      n=(n*10.0)+(*num++ -'0');       while (*num>='0' && *num<='9'); /* Number? */
-        if (*num=='.' && num[1]>='0' && num[1]<='9') {num++;            do      n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');}      /* Fractional part? */
-        if (*num=='e' || *num=='E')             /* Exponent? */
-        {       num++;if (*num=='+') num++;     else if (*num=='-') signsubscale=-1,num++;              /* With sign? */
-                while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0');   /* Number? */
-        }
-
-        n=sign*n*pow(10.0,(scale+subscale*signsubscale));       /* number = +/- number.fraction * 10^+/- exponent */
-        
-        item->valuedouble=n;
-        item->valueint=(int)n;
-        item->type=cJSON_Number;
-        return num;
-}
-
-/* Render the number nicely from the given item into a string. */
-static char *print_number(cJSON *item)
-{
-        char *str;
-        double d=item->valuedouble;
-        if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN)
-        {
-                str=(char*)cJSON_malloc(21);    /* 2^64+1 can be represented in 21 chars. */
-                if (str) sprintf(str,"%d",item->valueint);
-        }
-        else
-        {
-                str=(char*)cJSON_malloc(64);    /* This is a nice tradeoff. */
-                if (str)
-                {
-                        if (fabs(floor(d)-d)<=DBL_EPSILON && fabs(d)<1.0e60)sprintf(str,"%.0f",d);
-                        else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9)                       sprintf(str,"%e",d);
-                        else                                                                                            sprintf(str,"%f",d);
-                }
-        }
-        return str;
-}
-
-/* Parse the input text into an unescaped cstring, and populate item. */
-static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-static const char *parse_string(cJSON *item,const char *str)
-{
-        const char *ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc,uc2;
-        if (*str!='\"') {ep=str;return 0;}      /* not a string! */
-        
-        while (*ptr!='\"' && *ptr && ++len) if (*ptr++ == '\\') ptr++;  /* Skip escaped quotes. */
-        
-        out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */
-        if (!out) return 0;
-        
-        ptr=str+1;ptr2=out;
-        while (*ptr!='\"' && *ptr)
-        {
-                if (*ptr!='\\') *ptr2++=*ptr++;
-                else
-                {
-                        ptr++;
-                        switch (*ptr)
-                        {
-                                case 'b': *ptr2++='\b'; break;
-                                case 'f': *ptr2++='\f'; break;
-                                case 'n': *ptr2++='\n'; break;
-                                case 'r': *ptr2++='\r'; break;
-                                case 't': *ptr2++='\t'; break;
-                                case 'u':        /* transcode utf16 to utf8. */
-                                        sscanf(ptr+1,"%4x",&uc);ptr+=4; /* get the unicode char. */
-
-                                        if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0)        break;  /* check for invalid.   */
-
-                                        if (uc>=0xD800 && uc<=0xDBFF)   /* UTF16 surrogate pairs.       */
-                                        {
-                                                if (ptr[1]!='\\' || ptr[2]!='u')        break;  /* missing second-half of surrogate.    */
-                                                sscanf(ptr+3,"%4x",&uc2);ptr+=6;
-                                                if (uc2<0xDC00 || uc2>0xDFFF)           break;  /* invalid second-half of surrogate.    */
-                                                uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF));
-                                        }
-
-                                        len=4;if (uc<0x80) len=1;else if (uc<0x800) len=2;else if (uc<0x10000) len=3; ptr2+=len;
-                                        
-                                        switch (len) {
-                                                case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
-                                                case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
-                                                case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
-                                                case 1: *--ptr2 =(uc | firstByteMark[len]);
-                                        }
-                                        ptr2+=len;
-                                        break;
-                                default:  *ptr2++=*ptr; break;
-                        }
-                        ptr++;
-                }
-        }
-        *ptr2=0;
-        if (*ptr=='\"') ptr++;
-        item->valuestring=out;
-        item->type=cJSON_String;
-        return ptr;
-}
-
-/* Render the cstring provided to an escaped version that can be printed. */
-static char *print_string_ptr(const char *str)
-{
-        const char *ptr;char *ptr2,*out;int len=0;unsigned char token;
-        
-        if (!str) return cJSON_strdup("");
-        ptr=str;while ((token=*ptr) && ++len) {if (strchr("\"\\\b\f\n\r\t",token)) len++; else if (token<32) len+=5;ptr++;}
-        
-        out=(char*)cJSON_malloc(len+3);
-        if (!out) return 0;
-
-        ptr2=out;ptr=str;
-        *ptr2++='\"';
-        while (*ptr)
-        {
-                if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++;
-                else
-                {
-                        *ptr2++='\\';
-                        switch (token=*ptr++)
-                        {
-                                case '\\':      *ptr2++='\\';   break;
-                                case '\"':      *ptr2++='\"';   break;
-                                case '\b':      *ptr2++='b';    break;
-                                case '\f':      *ptr2++='f';    break;
-                                case '\n':      *ptr2++='n';    break;
-                                case '\r':      *ptr2++='r';    break;
-                                case '\t':      *ptr2++='t';    break;
-                                default: sprintf(ptr2,"u%04x",token);ptr2+=5;   break;  /* escape and print */
-                        }
-                }
-        }
-        *ptr2++='\"';*ptr2++=0;
-        return out;
-}
-/* Invote print_string_ptr (which is useful) on an item. */
-static char *print_string(cJSON *item)  {return print_string_ptr(item->valuestring);}
-
-/* Predeclare these prototypes. */
-static const char *parse_value(cJSON *item,const char *value);
-static char *print_value(cJSON *item,int depth,int fmt);
-static const char *parse_array(cJSON *item,const char *value);
-static char *print_array(cJSON *item,int depth,int fmt);
-static const char *parse_object(cJSON *item,const char *value);
-static char *print_object(cJSON *item,int depth,int fmt);
-
-/* Utility to jump whitespace and cr/lf */
-static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;}
-
-/* Parse an object - create a new root, and populate. */
-cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)
-{
-        const char *end=0;
-        cJSON *c=cJSON_New_Item();
-        ep=0;
-        if (!c) return 0;       /* memory fail */
-
-        end=parse_value(c,skip(value));
-        if (!end)       {cJSON_Delete(c);return 0;}     /* parse failure. ep is set. */
-
-        /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
-        if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}}
-        if (return_parse_end) *return_parse_end=end;
-        return c;
-}
-/* Default options for cJSON_Parse */
-cJSON *cJSON_Parse(const char *value) {return cJSON_ParseWithOpts(value,0,0);}
-
-/* Render a cJSON item/entity/structure to text. */
-char *cJSON_Print(cJSON *item)                          {return print_value(item,0,1);}
-char *cJSON_PrintUnformatted(cJSON *item)       {return print_value(item,0,0);}
-
-/* Parser core - when encountering text, process appropriately. */
-static const char *parse_value(cJSON *item,const char *value)
-{
-        if (!value)                                             return 0;       /* Fail on null. */
-        if (!strncmp(value,"null",4))   { item->type=cJSON_NULL;  return value+4; }
-        if (!strncmp(value,"false",5))  { item->type=cJSON_False; return value+5; }
-        if (!strncmp(value,"true",4))   { item->type=cJSON_True; item->valueint=1;      return value+4; }
-        if (*value=='\"')                               { return parse_string(item,value); }
-        if (*value=='-' || (*value>='0' && *value<='9'))        { return parse_number(item,value); }
-        if (*value=='[')                                { return parse_array(item,value); }
-        if (*value=='{')                                { return parse_object(item,value); }
-
-        ep=value;return 0;      /* failure. */
-}
-
-/* Render a value to text. */
-static char *print_value(cJSON *item,int depth,int fmt)
-{
-        char *out=0;
-        if (!item) return 0;
-        switch ((item->type)&255)
-        {
-                case cJSON_NULL:        out=cJSON_strdup("null");       break;
-                case cJSON_False:       out=cJSON_strdup("false");break;
-                case cJSON_True:        out=cJSON_strdup("true"); break;
-                case cJSON_Number:      out=print_number(item);break;
-                case cJSON_String:      out=print_string(item);break;
-                case cJSON_Array:       out=print_array(item,depth,fmt);break;
-                case cJSON_Object:      out=print_object(item,depth,fmt);break;
-        }
-        return out;
-}
-
-/* Build an array from input text. */
-static const char *parse_array(cJSON *item,const char *value)
-{
-        cJSON *child;
-        if (*value!='[')        {ep=value;return 0;}    /* not an array! */
-
-        item->type=cJSON_Array;
-        value=skip(value+1);
-        if (*value==']') return value+1;        /* empty array. */
-
-        item->child=child=cJSON_New_Item();
-        if (!item->child) return 0;              /* memory fail */
-        value=skip(parse_value(child,skip(value)));     /* skip any spacing, get the value. */
-        if (!value) return 0;
-
-        while (*value==',')
-        {
-                cJSON *new_item;
-                if (!(new_item=cJSON_New_Item())) return 0;     /* memory fail */
-                child->next=new_item;new_item->prev=child;child=new_item;
-                value=skip(parse_value(child,skip(value+1)));
-                if (!value) return 0;   /* memory fail */
-        }
-
-        if (*value==']') return value+1;        /* end of array */
-        ep=value;return 0;      /* malformed. */
-}
-
-/* Render an array to text */
-static char *print_array(cJSON *item,int depth,int fmt)
-{
-        char **entries;
-        char *out=0,*ptr,*ret;int len=5;
-        cJSON *child=item->child;
-        int numentries=0,i=0,fail=0;
-        
-        /* How many entries in the array? */
-        while (child) numentries++,child=child->next;
-        /* Explicitly handle numentries==0 */
-        if (!numentries)
-        {
-                out=(char*)cJSON_malloc(3);
-                if (out) strcpy(out,"[]");
-                return out;
-        }
-        /* Allocate an array to hold the values for each */
-        entries=(char**)cJSON_malloc(numentries*sizeof(char*));
-        if (!entries) return 0;
-        memset(entries,0,numentries*sizeof(char*));
-        /* Retrieve all the results: */
-        child=item->child;
-        while (child && !fail)
-        {
-                ret=print_value(child,depth+1,fmt);
-                entries[i++]=ret;
-                if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1;
-                child=child->next;
-        }
-        
-        /* If we didn't fail, try to malloc the output string */
-        if (!fail) out=(char*)cJSON_malloc(len);
-        /* If that fails, we fail. */
-        if (!out) fail=1;
-
-        /* Handle failure. */
-        if (fail)
-        {
-                for (i=0;i<numentries;i++) if (entries[i]) cJSON_free(entries[i]);
-                cJSON_free(entries);
-                return 0;
-        }
-        
-        /* Compose the output array. */
-        *out='[';
-        ptr=out+1;*ptr=0;
-        for (i=0;i<numentries;i++)
-        {
-                strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
-                if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;}
-                cJSON_free(entries[i]);
-        }
-        cJSON_free(entries);
-        *ptr++=']';*ptr++=0;
-        return out;     
-}
-
-/* Build an object from the text. */
-static const char *parse_object(cJSON *item,const char *value)
-{
-        cJSON *child;
-        if (*value!='{')        {ep=value;return 0;}    /* not an object! */
-        
-        item->type=cJSON_Object;
-        value=skip(value+1);
-        if (*value=='}') return value+1;        /* empty array. */
-        
-        item->child=child=cJSON_New_Item();
-        if (!item->child) return 0;
-        value=skip(parse_string(child,skip(value)));
-        if (!value) return 0;
-        child->string=child->valuestring;child->valuestring=0;
-        if (*value!=':') {ep=value;return 0;}   /* fail! */
-        value=skip(parse_value(child,skip(value+1)));   /* skip any spacing, get the value. */
-        if (!value) return 0;
-        
-        while (*value==',')
-        {
-                cJSON *new_item;
-                if (!(new_item=cJSON_New_Item()))       return 0; /* memory fail */
-                child->next=new_item;new_item->prev=child;child=new_item;
-                value=skip(parse_string(child,skip(value+1)));
-                if (!value) return 0;
-                child->string=child->valuestring;child->valuestring=0;
-                if (*value!=':') {ep=value;return 0;}   /* fail! */
-                value=skip(parse_value(child,skip(value+1)));   /* skip any spacing, get the value. */
-                if (!value) return 0;
-        }
-        
-        if (*value=='}') return value+1;        /* end of array */
-        ep=value;return 0;      /* malformed. */
-}
-
-/* Render an object to text. */
-static char *print_object(cJSON *item,int depth,int fmt)
-{
-        char **entries=0,**names=0;
-        char *out=0,*ptr,*ret,*str;int len=7,i=0,j;
-        cJSON *child=item->child;
-        int numentries=0,fail=0;
-        /* Count the number of entries. */
-        while (child) numentries++,child=child->next;
-        /* Explicitly handle empty object case */
-        if (!numentries)
-        {
-                out=(char*)cJSON_malloc(fmt?depth+3:3);
-                if (!out)       return 0;
-                ptr=out;*ptr++='{';
-                if (fmt) {*ptr++='\n';for (i=0;i<depth-1;i++) *ptr++='\t';}
-                *ptr++='}';*ptr++=0;
-                return out;
-        }
-        /* Allocate space for the names and the objects */
-        entries=(char**)cJSON_malloc(numentries*sizeof(char*));
-        if (!entries) return 0;
-        names=(char**)cJSON_malloc(numentries*sizeof(char*));
-        if (!names) {cJSON_free(entries);return 0;}
-        memset(entries,0,sizeof(char*)*numentries);
-        memset(names,0,sizeof(char*)*numentries);
-
-        /* Collect all the results into our arrays: */
-        child=item->child;depth++;if (fmt) len+=depth;
-        while (child)
-        {
-                names[i]=str=print_string_ptr(child->string);
-                entries[i++]=ret=print_value(child,depth,fmt);
-                if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1;
-                child=child->next;
-        }
-        
-        /* Try to allocate the output string */
-        if (!fail) out=(char*)cJSON_malloc(len);
-        if (!out) fail=1;
-
-        /* Handle failure */
-        if (fail)
-        {
-                for (i=0;i<numentries;i++) {if (names[i]) cJSON_free(names[i]);if (entries[i]) cJSON_free(entries[i]);}
-                cJSON_free(names);cJSON_free(entries);
-                return 0;
-        }
-        
-        /* Compose the output: */
-        *out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0;
-        for (i=0;i<numentries;i++)
-        {
-                if (fmt) for (j=0;j<depth;j++) *ptr++='\t';
-                strcpy(ptr,names[i]);ptr+=strlen(names[i]);
-                *ptr++=':';if (fmt) *ptr++='\t';
-                strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
-                if (i!=numentries-1) *ptr++=',';
-                if (fmt) *ptr++='\n';*ptr=0;
-                cJSON_free(names[i]);cJSON_free(entries[i]);
-        }
-        
-        cJSON_free(names);cJSON_free(entries);
-        if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';
-        *ptr++='}';*ptr++=0;
-        return out;     
-}
-
-/* Get Array size/item / object item. */
-int    cJSON_GetArraySize(cJSON *array)                                                 {cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;}
-cJSON *cJSON_GetArrayItem(cJSON *array,int item)                                {cJSON *c=array->child;  while (c && item>0) item--,c=c->next; return c;}
-cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)    {cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;}
-
-/* Utility for array list handling. */
-static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;}
-/* Utility for handling references. */
-static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();if (!ref) return 0;memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;}
-
-/* Add item to array/object. */
-void   cJSON_AddItemToArray(cJSON *array, cJSON *item)                                          {cJSON *c=array->child;if (!item) return; if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}}
-void   cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)      {if (!item) return; if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);}
-void    cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)                                                {cJSON_AddItemToArray(array,create_reference(item));}
-void    cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)    {cJSON_AddItemToObject(object,string,create_reference(item));}
-
-cJSON *cJSON_DetachItemFromArray(cJSON *array,int which)                        {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0;
-        if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;}
-void   cJSON_DeleteItemFromArray(cJSON *array,int which)                        {cJSON_Delete(cJSON_DetachItemFromArray(array,which));}
-cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;}
-void   cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));}
-
-/* Replace array/object items with new ones. */
-void   cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)          {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return;
-        newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem;
-        if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);}
-void   cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}}
-
-/* Create basic types: */
-cJSON *cJSON_CreateNull(void)                                   {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;}
-cJSON *cJSON_CreateTrue(void)                                   {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;}
-cJSON *cJSON_CreateFalse(void)                                  {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;}
-cJSON *cJSON_CreateBool(int b)                                  {cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;}
-cJSON *cJSON_CreateNumber(double num)                   {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;}return item;}
-cJSON *cJSON_CreateString(const char *string)   {cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;}
-cJSON *cJSON_CreateArray(void)                                  {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Array;return item;}
-cJSON *cJSON_CreateObject(void)                                 {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Object;return item;}
-
-/* Create Arrays: */
-cJSON *cJSON_CreateIntArray(int *numbers,int count)                             {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-cJSON *cJSON_CreateFloatArray(float *numbers,int count)                 {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-cJSON *cJSON_CreateDoubleArray(double *numbers,int count)               {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-cJSON *cJSON_CreateStringArray(const char **strings,int count)  {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-
-/* Duplication */
-cJSON *cJSON_Duplicate(cJSON *item,int recurse)
-{
-        cJSON *newitem,*cptr,*nptr=0,*newchild;
-        /* Bail on bad ptr */
-        if (!item) return 0;
-        /* Create new item */
-        newitem=cJSON_New_Item();
-        if (!newitem) return 0;
-        /* Copy over all vars */
-        newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble;
-        if (item->valuestring)  {newitem->valuestring=cJSON_strdup(item->valuestring);  if (!newitem->valuestring)      {cJSON_Delete(newitem);return 0;}}
-        if (item->string)               {newitem->string=cJSON_strdup(item->string);                    if (!newitem->string)           {cJSON_Delete(newitem);return 0;}}
-        /* If non-recursive, then we're done! */
-        if (!recurse) return newitem;
-        /* Walk the ->next chain for the child. */
-        cptr=item->child;
-        while (cptr)
-        {
-                newchild=cJSON_Duplicate(cptr,1);               /* Duplicate (with recurse) each item in the ->next chain */
-                if (!newchild) {cJSON_Delete(newitem);return 0;}
-                if (nptr)       {nptr->next=newchild,newchild->prev=nptr;nptr=newchild;}        /* If newitem->child already set, then crosswire ->prev and ->next and move on */
-                else            {newitem->child=newchild;nptr=newchild;}                                        /* Set newitem->child and move to it */
-                cptr=cptr->next;
-        }
-        return newitem;
-}
-
-

external/cjson/cJSON.h

@@ -1,143 +0,0 @@
-/*
-  Copyright (c) 2009 Dave Gamble
- 
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
- 
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
- 
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-#ifndef cJSON__h
-#define cJSON__h
-
-#include <stdlib.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/* cJSON Types: */
-#define cJSON_False 0
-#define cJSON_True 1
-#define cJSON_NULL 2
-#define cJSON_Number 3
-#define cJSON_String 4
-#define cJSON_Array 5
-#define cJSON_Object 6
-	
-#define cJSON_IsReference 256
-
-/* The cJSON structure: */
-typedef struct cJSON {
-	struct cJSON *next,*prev;	/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
-	struct cJSON *child;		/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
-
-	int type;					/* The type of the item, as above. */
-
-	char *valuestring;			/* The item's string, if type==cJSON_String */
-	int valueint;				/* The item's number, if type==cJSON_Number */
-	double valuedouble;			/* The item's number, if type==cJSON_Number */
-
-	char *string;				/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
-} cJSON;
-
-typedef struct cJSON_Hooks {
-      void *(*malloc_fn)(size_t sz);
-      void (*free_fn)(void *ptr);
-} cJSON_Hooks;
-
-/* Supply malloc, realloc and free functions to cJSON */
-extern void cJSON_InitHooks(cJSON_Hooks* hooks);
-
-
-/* Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. */
-extern cJSON *cJSON_Parse(const char *value);
-/* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */
-extern char  *cJSON_Print(cJSON *item);
-/* Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished. */
-extern char  *cJSON_PrintUnformatted(cJSON *item);
-/* Delete a cJSON entity and all subentities. */
-extern void   cJSON_Delete(cJSON *c);
-
-/* Returns the number of items in an array (or object). */
-extern int	  cJSON_GetArraySize(cJSON *array);
-/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
-extern cJSON *cJSON_GetArrayItem(cJSON *array,int item);
-/* Get item "string" from object. Case insensitive. */
-extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);
-
-/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
-extern const char *cJSON_GetErrorPtr(void);
-	
-/* These calls create a cJSON item of the appropriate type. */
-extern cJSON *cJSON_CreateNull(void);
-extern cJSON *cJSON_CreateTrue(void);
-extern cJSON *cJSON_CreateFalse(void);
-extern cJSON *cJSON_CreateBool(int b);
-extern cJSON *cJSON_CreateNumber(double num);
-extern cJSON *cJSON_CreateString(const char *string);
-extern cJSON *cJSON_CreateArray(void);
-extern cJSON *cJSON_CreateObject(void);
-
-/* These utilities create an Array of count items. */
-extern cJSON *cJSON_CreateIntArray(int *numbers,int count);
-extern cJSON *cJSON_CreateFloatArray(float *numbers,int count);
-extern cJSON *cJSON_CreateDoubleArray(double *numbers,int count);
-extern cJSON *cJSON_CreateStringArray(const char **strings,int count);
-
-/* Append item to the specified array/object. */
-extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
-extern void	cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
-/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
-extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
-extern void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);
-
-/* Remove/Detatch items from Arrays/Objects. */
-extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int which);
-extern void   cJSON_DeleteItemFromArray(cJSON *array,int which);
-extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string);
-extern void   cJSON_DeleteItemFromObject(cJSON *object,const char *string);
-	
-/* Update array items. */
-extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);
-extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
-
-/* Duplicate a cJSON item */
-extern cJSON *cJSON_Duplicate(cJSON *item,int recurse);
-/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
-need to be released. With recurse!=0, it will duplicate any children connected to the item.
-The item->next and ->prev pointers are always zero on return from Duplicate. */
-
-/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
-extern cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated);
-
-/* Macros for creating things quickly. */
-#define cJSON_AddNullToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateNull())
-#define cJSON_AddTrueToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
-#define cJSON_AddFalseToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
-#define cJSON_AddBoolToObject(object,name,b)	cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
-#define cJSON_AddNumberToObject(object,name,n)	cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
-#define cJSON_AddStringToObject(object,name,s)	cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
-
-/* When assigning an integer value, it needs to be propagated to valuedouble too. */
-#define cJSON_SetIntValue(object,val)			((object)?(object)->valueint=(object)->valuedouble=(val):(val))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

jenkins/build-opm-module.sh

@@ -36,7 +36,7 @@ function parseRevisions {
   declare -a BTYPES_ARRAY
   for btype in $BTYPES
   do
-    BTYPES_ARRAY=(${BTYPES_ARRAY[*]} $btype)
+    BTYPES_ARRAY=($BTYPES_ARRAY $btype)
   done
   TOOLCHAIN_ARRAY=($CMAKE_TOOLCHAIN_FILES)
   for index in ${!BTYPES_ARRAY[*]}
@@ -132,7 +132,6 @@ function clone_module {
   fi
   git fetch --depth 1 origin $2:branch_to_build
   git checkout branch_to_build
-  git log HEAD -1 | cat
   test $? -eq 0 || exit 1
   popd
 }
@@ -173,12 +172,17 @@ function build_upstreams {
 # Uses pre-filled arrays downstreams, and associativ array downstreamRev
 # which holds the default revisions to use for downstreams
 function build_downstreams {
+  pushd .
+  cd $WORKSPACE/$configuration/build-$1
+  cmake --build . --target install
+  popd
+
   egrep_cmd="xml_grep --wrap testsuites --cond testsuite $WORKSPACE/$configuration/build-$1/testoutput.xml"
   for downstream in ${downstreams[*]}
   do
     echo "Building downstream $downstream=${downstreamRev[$downstream]} configuration=$configuration"
     # Build downstream and execute installation
-    clone_and_build_module $downstream "-DCMAKE_PREFIX_PATH=$WORKSPACE/$configuration/install -DCMAKE_INSTALL_PREFIX=$WORKSPACE/$configuration/install -DOPM_TESTS_ROOT=$OPM_TESTS_ROOT" ${downstreamRev[$downstream]} $WORKSPACE/$configuration 1
+    clone_and_build_module $downstream "-DCMAKE_PREFIX_PATH=$WORKSPACE/$configuration/install -DCMAKE_INSTALL_PREFIX=$WORKSPACE/$configuration/install -DOPM_DATA_ROOT=$OPM_DATA_ROOT" ${downstreamRev[$downstream]} $WORKSPACE/$configuration 1
     test $? -eq 0 || exit 1
 
     # Installation for downstream
@@ -215,9 +219,7 @@ function build_module_full {
     mkdir -p $configuration/build-$1
     cd $configuration/build-$1
     echo "Building main module $1=$sha1 configuration=$configuration"
-    build_module "-DCMAKE_INSTALL_PREFIX=$WORKSPACE/$configuration/install -DOPM_TESTS_ROOT=$OPM_TESTS_ROOT" 1 $WORKSPACE
-    test $? -eq 0 || exit 1
-    cmake --build . --target install
+    build_module "-DCMAKE_INSTALL_PREFIX=$WORKSPACE/$configuration/install -DOPM_DATA_ROOT=$OPM_DATA_ROOT" 1 $WORKSPACE
     test $? -eq 0 || exit 1
     popd
 

jenkins/build.sh

@@ -6,24 +6,26 @@ source `dirname $0`/build-opm-module.sh
 mkdir deps
 ln -sf $WORKSPACE deps/opm-common
 
-declare -a upstreams
-upstreams=(libecl)
-
-declare -A upstreamRev
-upstreamRev[libecl]=master
-
 # Downstreams and revisions
 declare -a downstreams
-downstreams=(opm-material
+downstreams=(libecl
+             opm-parser
+             opm-output
+             opm-material
              opm-grid
+             opm-core
              ewoms
              opm-simulators
              opm-upscaling
              )
 
 declare -A downstreamRev
+downstreamRev[libecl]=master
+downstreamRev[opm-parser]=master
 downstreamRev[opm-material]=master
+downstreamRev[opm-core]=master
 downstreamRev[opm-grid]=master
+downstreamRev[opm-output]=master
 downstreamRev[ewoms]=master
 downstreamRev[opm-simulators]=master
 downstreamRev[opm-upscaling]=master
@@ -31,7 +33,10 @@ downstreamRev[opm-upscaling]=master
 parseRevisions
 printHeader opm-common
 
-# Setup opm-data
-source $WORKSPACE/deps/opm-common/jenkins/setup-opm-tests.sh
+# Setup opm-data if necessary
+if grep -q "with downstreams" <<< $ghprbCommentBody
+then
+  source $WORKSPACE/deps/opm-common/jenkins/setup-opm-data.sh
+fi
 
 build_module_full opm-common

jenkins/setup-opm-data.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Predefined by environment
+if test -z "$OPM_DATA_ROOT"
+then
+  OPM_DATA_REVISION="master"
+  if grep -q "opm-data=" <<< $ghprbCommentBody
+  then
+    OPM_DATA_REVISION=pull/`echo $ghprbCommentBody | sed -r 's/.*opm-data=([0-9]+).*/\1/g'`/merge
+  fi
+  # Not specified in trigger, use shared copy
+  if [[ "$OPM_DATA_REVISION" = "master" ]] && [[ ! "$OPM_DATA_ROOT_PREDEFINED" = "" ]]
+  then
+    if ! test -d $WORKSPACE/deps/opm-data
+    then
+      cp $OPM_DATA_ROOT_PREDEFINED $WORKSPACE/deps/opm-data -R
+    fi
+  else
+    # Specified in trigger, download it
+    source $WORKSPACE/deps/opm-common/jenkins/build-opm-module.sh
+    clone_module opm-data $OPM_DATA_REVISION
+  fi
+else
+  if ! test -d $WORKSPACE/deps/opm-data
+  then
+    cp $OPM_DATA_ROOT $WORKSPACE/deps/opm-data -R
+  fi
+fi
+OPM_DATA_ROOT=$WORKSPACE/deps/opm-data

jenkins/setup-opm-tests.sh

@@ -1,29 +0,0 @@
-#!/bin/bash
-
-# Predefined by environment
-if test -z "$OPM_TESTS_ROOT"
-then
-  OPM_TESTS_REVISION="master"
-  if grep -q "opm-tests=" <<< $ghprbCommentBody
-  then
-    OPM_TESTS_REVISION=pull/`echo $ghprbCommentBody | sed -r 's/.*opm-tests=([0-9]+).*/\1/g'`/merge
-  fi
-  # Not specified in trigger, use shared copy
-  if [[ "$OPM_TESTS_REVISION" = "master" ]] && [[ ! "$OPM_TESTS_ROOT_PREDEFINED" = "" ]]
-  then
-    if ! test -d $WORKSPACE/deps/opm-tests
-    then
-      cp $OPM_TESTS_ROOT_PREDEFINED $WORKSPACE/deps/opm-tests -R
-    fi
-  else
-    # Specified in trigger, download it
-    source $WORKSPACE/deps/opm-common/jenkins/build-opm-module.sh
-    clone_module opm-tests $OPM_TESTS_REVISION
-  fi
-else
-  if ! test -d $WORKSPACE/deps/opm-tests
-  then
-    cp $OPM_TESTS_ROOT $WORKSPACE/deps/opm-tests -R
-  fi
-fi
-OPM_TESTS_ROOT=$WORKSPACE/deps/opm-tests

jenkins/update-opm-data.sh

@@ -7,8 +7,11 @@ source $WORKSPACE/deps/opm-common/jenkins/build-opm-module.sh
 declare -a upstreams # Everything is considered an upstream to aid code reuse
 upstreams=(libecl
            opm-common
+           opm-parser
+           opm-output
            opm-material
            opm-grid
+           opm-core
            ewoms
            opm-simulators
            opm-upscaling
@@ -17,8 +20,11 @@ upstreams=(libecl
 declare -A upstreamRev
 upstreamRev[libecl]=master
 upstreamRev[opm-common]=master
+upstreamRev[opm-parser]=master
 upstreamRev[opm-material]=master
+upstreamRev[opm-core]=master
 upstreamRev[opm-grid]=master
+upstreamRev[opm-output]=master
 upstreamRev[ewoms]=master
 upstreamRev[opm-simulators]=master
 upstreamRev[opm-upscaling]=master
@@ -44,11 +50,11 @@ done
 # Do the commit
 export REASON
 export BRANCH_NAME
-$WORKSPACE/deps/opm-simulators/tests/update_reference_data.sh $OPM_TESTS_ROOT
+$WORKSPACE/deps/opm-simulators/tests/update_reference_data.sh $OPM_DATA_ROOT
 
 # Finally open the pull request
-cd $OPM_TESTS_ROOT
-git remote add jenkins4opm git@github.com:jenkins4opm/opm-tests
+cd $OPM_DATA_ROOT
+git remote add jenkins4opm git@github.com:jenkins4opm/opm-data
 
 # Do some cleaning of old remote branches
 # Easier code with git 2.7+
@@ -79,9 +85,9 @@ then
   GH_TOKEN=`git config --get gitOpenPull.Token`
   REV=${upstreamRev[$MAIN_REPO]}
   PRNUMBER=${rev//[!0-9]/}
-  DATA_PR=`curl -X GET https://api.github.com/repos/OPM/opm-tests/pulls?head=jenkins4opm:$BRANCH_NAME | grep '"number":' | awk -F ':' '{print $2}' | sed -e 's/,//' -e 's/ //'`
+  DATA_PR=`curl -X GET https://api.github.com/repos/OPM/opm-data/pulls?head=jenkins4opm:$BRANCH_NAME | grep '"number":' | awk -F ':' '{print $2}' | sed -e 's/,//'`
   git push -u jenkins4opm $BRANCH_NAME -f
-  curl -d "{ \"body\": \"Existing PR https://github.com/OPM/opm-tests/pull/$DATA_PR was updated\" }" -X POST https://api.github.com/repos/OPM/$MAIN_REPO/issues/$PRNUMBER/comments?access_token=$GH_TOKEN
+  curl -d "{ \"body\": \"Existing PR https://github.com/OPM/opm-data/pull/$DATA_PR was updated\" }" -X POST https://api.github.com/repos/OPM/$MAIN_REPO/issues/$PRNUMBER/comments?access_token=$GH_TOKEN
 else
-  git-open-pull -u jenkins4opm --base-account OPM --base-repo opm-tests -r /tmp/cmsg $BRANCH_NAME
+  git-open-pull -u jenkins4opm --base-account OPM --base-repo opm-data -r /tmp/cmsg $BRANCH_NAME
 fi

opm-common-prereqs.cmake

@@ -1,31 +0,0 @@
-# -*- 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:
-
-# defines that must be present in config.h for our headers
-set (opm-common_CONFIG_VAR
-	"HAS_ATTRIBUTE_UNUSED")
-
-# dependencies
-set (opm-common_DEPS
-	# compile with C99 support if available
-	"C99"
-	# compile with C++0x/11 support if available
-	"CXX11Features REQUIRED"
-	)
-
-if(ENABLE_ECL_INPUT)
-  list(APPEND opm-common_DEPS
-        "ecl REQUIRED"
-        # various runtime library enhancements
-        "Boost 1.44.0
-          COMPONENTS system filesystem unit_test_framework regex REQUIRED")
-else()
-  list(APPEND opm-common_DEPS
-        # various runtime library enhancements
-        "Boost 1.44.0
-          COMPONENTS system unit_test_framework REQUIRED")
-endif()
-# We need a defined target for libecl when linking.
-# The definition of the target is done implicitly below when
-# libecl is searched for.
-find_package_deps(opm-common)

opm/common/OpmLog/MessageLimiter.hpp

@@ -53,8 +53,7 @@ namespace Opm
         /// to obtain that behaviour.
         explicit MessageLimiter(const int tag_limit)
             : tag_limit_(tag_limit < 0 ? NoLimit : tag_limit),
-              category_limits_({{Log::MessageType::Debug, NoLimit},
-		                {Log::MessageType::Note, NoLimit},
+              category_limits_({{Log::MessageType::Note, NoLimit},
                                 {Log::MessageType::Info, NoLimit},
                                 {Log::MessageType::Warning, NoLimit},
                                 {Log::MessageType::Error, NoLimit},
@@ -69,8 +68,7 @@ namespace Opm
         {
             // Must ensure NoLimit for categories that are not
             // explicitly specified in the input.
-            for (auto category : { Log::MessageType::Debug,
-		                   Log::MessageType::Note,
+            for (auto category : { Log::MessageType::Note,
                                    Log::MessageType::Info,
                                    Log::MessageType::Warning,
                                    Log::MessageType::Error,

opm/common/OpmLog/OpmLog.cpp

@@ -23,20 +23,7 @@
 #include <iostream>
 #include <errno.h>  // For errno
 #include <stdio.h>  // For fileno() and stdout
-
-#if defined(_MSC_VER)
-// MS put some POSIX-like functions in io.h, but prefix them with underscore
-// since they are considered "vendor" and not standard functions.
-#define _CRT_NONSTDC_NO_DEPRECATE
-#include <io.h>
-#define isatty _isatty
-#elif defined(__MINGW32__)
-// MinGW also has the isatty function in io.h instead of unistd.h, but without
-// the underscore.
-#include <io.h>
-#else
 #include <unistd.h> // For isatty()
-#endif
 
 namespace Opm {
 

opm/common/ResetLocale.hpp

@@ -0,0 +1,62 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*!
+ * \file
+ * \brief Provides a free function to reset the localization settings
+ *
+ * Under some circumstances, some environments seem to set a locale which they do not
+ * install. In turn this leads to std::runtime_errror being thrown by some parts of Boost
+ * (for some versions) which causes unsolicited program aborts.
+ *
+ * This issue asside, it looks pretty weird if the e.g. the number format is inconsistent
+ * with the language used by rest of the simulation.
+ */
+#ifndef OPM_RESET_LOCALE_HH
+#define OPM_RESET_LOCALE_HH
+
+#include <stdlib.h>
+
+namespace Opm {
+
+inline void resetLocale()
+{
+#ifndef WIN32
+    // this probably only works for POSIX compatible operating systems. for all others,
+    // unsetting a few environment variables should not hurt, though.
+    unsetenv("LC_ALL");
+    unsetenv("LANG");
+    unsetenv("LANGUAGE");
+    unsetenv("LC_ADDRESS");
+    unsetenv("LC_COLLATE");
+    unsetenv("LC_CTYPE");
+    unsetenv("LC_IDENTIFICATION");
+    unsetenv("LC_MEASUREMENT");
+    unsetenv("LC_MESSAGES");
+    unsetenv("LC_MONETARY");
+    unsetenv("LC_NAME");
+    unsetenv("LC_NUMERIC");
+    unsetenv("LC_PAPER");
+    unsetenv("LC_TELEPHONE");
+    unsetenv("LC_TIME");
+#endif // !WIN32
+}
+
+} // namespace Opm
+
+#endif

opm/common/Unused.hpp

@@ -1,6 +1,6 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
 /*
-  Copyright (C) 2017 TNO
-
   This file is part of the Open Porous Media project (OPM).
 
   OPM is free software: you can redistribute it and/or modify
@@ -15,23 +15,29 @@
 
   You should have received a copy of the GNU General Public License
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*!
+ * \file
+ * \brief Provides the OPM_UNUSED macro
+ *
+ * This macro can be used to mark variables as "potentially unused" which suppresses some
+ * bogus compiler warnings. If the compiler does not support this, the macro is a no-op.
  */
-#ifndef OPM_PARSER_AQUTAB_TABLE_HPP
-#define OPM_PARSER_AQUTAB_TABLE_HPP
+#ifndef OPM_UNUSED_HH
+#define OPM_UNUSED_HH
 
-#include "SimpleTable.hpp"
+#ifndef HAS_ATTRIBUTE_UNUSED
+#define OPM_UNUSED
+#else
+#define OPM_UNUSED __attribute__((unused))
+#endif
 
-namespace Opm {
-
-    class DeckItem;
-
-    class AqutabTable : public SimpleTable {
-    public:
-        AqutabTable( const DeckItem& item );
-
-        const TableColumn& getTimeColumn() const;
-        const TableColumn& getPressureColumn() const;
-    };
-}
+#ifdef NDEBUG
+#define OPM_DEBUG_UNUSED
+#define OPM_OPTIM_UNUSED OPM_UNUSED
+#else
+#define OPM_DEBUG_UNUSED OPM_UNUSED
+#define OPM_OPTIM_UNUSED
+#endif
 
 #endif

opm/common/Valgrind.hpp

@@ -0,0 +1,311 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 2 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+
+  Consult the COPYING file in the top-level source directory of this
+  module for the precise wording of the license and the list of
+  copyright holders.
+*/
+/*!
+ * \file
+ * \brief Some templates to wrap the valgrind client request macros
+ */
+#ifndef OPM_VALGRIND_HPP
+#define OPM_VALGRIND_HPP
+
+#include <opm/common/Unused.hpp>
+
+#if HAVE_VALGRIND
+#include <valgrind/memcheck.h>
+#endif
+
+#if HAVE_VALGRIND
+#define OPM_VALGRIND_OPTIM_UNUSED OPM_OPTIM_UNUSED
+#else
+#define OPM_VALGRIND_OPTIM_UNUSED OPM_UNUSED
+#endif
+
+namespace Opm {
+namespace Valgrind {
+/*!
+ * \ingroup Valgrind
+ * \brief Returns whether the program is running under Valgrind or not.
+ */
+inline bool IsRunning()
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    return RUNNING_ON_VALGRIND;
+#else
+    return false;
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make valgrind complain if any of the memory occupied by an object
+ *        is undefined.
+ *
+ * Please note that this does not check whether the destinations of an
+ * object's pointers or references are defined. Also, for performance
+ * reasons the compiler might insert "padding bytes" between within
+ * the objects which leads to false positives.
+ *
+ * Example:
+ *
+ * \code
+ * int i;
+ * Valgrind::CheckDefined(i); // Valgrind complains!
+ * \endcode
+ *
+ * \tparam T The type of the object which ought to be checked
+ *
+ * \param value the object which valgrind should check
+ *
+ * \return true iff there are no undefined bytes in the memory
+ *         occupied by the object.
+ */
+template <class T>
+inline bool CheckDefined(const T& value OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    auto tmp = VALGRIND_CHECK_MEM_IS_DEFINED(&value, sizeof(T));
+    return tmp == 0;
+#else
+    return true;
+#endif
+}
+
+
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make valgrind complain if any of the memory occupied by an object
+ *        is not addressable.
+ *
+ * Example:
+ *
+ * \code
+ * int* i = NULL;
+ * Valgrind::CheckAddressable(*i); // Valgrind complains!
+ * \endcode
+ *
+ * \tparam T The type of the object which ought to be checked
+ *
+ * \param value the object which valgrind should check
+ *
+ * \return true iff there are no unadressable bytes in the memory
+ *         occupied by the object.
+ */
+template <class T>
+inline bool CheckAddressable(const T& value OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    auto tmp = VALGRIND_CHECK_MEM_IS_ADDRESSABLE(&value, sizeof(T));
+    return tmp == 0;
+#else
+    return true;
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make valgrind complain if any of the the memory occupied
+ *        by a C-style array objects is undefined.
+ *
+ * Please note that this does not check whether the destinations of an
+ * object's pointers or references are defined. Also, for performance
+ * reasons the compiler might insert "padding bytes" between within
+ * the objects which leads to false positives.
+ *
+ * Example:
+ *
+ * \code
+ * int i[2];
+ * Valgrind::CheckDefined(i, 2); // Valgrind complains!
+ * \endcode
+ *
+ * \tparam T The type of the object which ought to be checked
+ *
+ * \param value Pointer to the first object of the array.
+ * \param size The size of the array in number of objects
+ *
+ * \return true iff there are no undefined bytes in the memory
+ *         occupied by the array.
+ */
+template <class T>
+inline bool CheckDefined(const T* value OPM_VALGRIND_OPTIM_UNUSED, int size OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    auto tmp = VALGRIND_CHECK_MEM_IS_DEFINED(value, size*sizeof(T));
+    return tmp == 0;
+#else
+    return true;
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make the memory on which an object resides undefined in
+ *        valgrind runs.
+ *
+ * Example:
+ *
+ * \code
+ * int i = 0;
+ * Valgrind::SetUndefined(i);
+ * Valgrind::CheckDefined(i); // Valgrind complains!
+ * \endcode
+ *
+ * \tparam T The type of the object which ought to be set to undefined
+ *
+ * \param value The object which's memory valgrind should be told is undefined
+ */
+template <class T>
+inline void SetUndefined(const T &value OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    VALGRIND_MAKE_MEM_UNDEFINED(&value, sizeof(T));
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make the memory on which an array of object resides
+ *        undefined in valgrind runs.
+ *
+ * Example:
+ *
+ * \code
+ * int i[3] = {0, 1, 3};
+ * Valgrind::SetUndefined(&i[1], 2);
+ * Valgrind::CheckDefined(i, 3); // Valgrind complains!
+ * \endcode
+ *
+ * \tparam T The type of the object which ought to be set to undefined
+ *
+ * \param value Pointer to the first object of the array.
+ * \param size The size of the array in number of objects
+ */
+template <class T>
+inline void SetUndefined(const T* value OPM_VALGRIND_OPTIM_UNUSED, int size OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    VALGRIND_MAKE_MEM_UNDEFINED(value, size*sizeof(T));
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make the memory on which an object resides defined.
+ *
+ * Example:
+ *
+ * \code
+ * int i;
+ * Valgrind::SetDefined(i);
+ * Valgrind::CheckDefined(i); // Valgrind does not complain!
+ * \endcode
+ *
+ * \tparam T The type of the object which valgrind should consider as defined
+ *
+ * \param value The object which's memory valgrind should consider as defined
+ */
+template <class T>
+inline void SetDefined(const T& value OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    VALGRIND_MAKE_MEM_DEFINED(&value, sizeof(T));
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make the memory on which a C-style array of objects resides
+ *        defined.
+ *
+ * Example:
+ *
+ * \code
+ * int i[3];
+ * Valgrind::SetDefined(i, 3);
+ * Valgrind::CheckDefined(i, 3); // Valgrind does not complain!
+ * \endcode
+ *
+ * \tparam T The type of the object which valgrind should consider as defined
+ *
+ * \param value Pointer to the first object of the array.
+ * \param n The size of the array in number of objects
+ */
+template <class T>
+inline void SetDefined(const T *value OPM_VALGRIND_OPTIM_UNUSED, int n OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    VALGRIND_MAKE_MEM_DEFINED(value, n*sizeof(T));
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make valgrind complain if an object's memory is accessed.
+ *
+ * Example:
+ *
+ * \code
+ * int i = 1;
+ * Valgrind::SetNoAccess(i);
+ * int j = i; // Valgrind complains!
+ * \endcode
+ *
+ * \tparam T The type of the object which valgrind should complain if accessed
+ *
+ * \param value The object which's memory valgrind should complain if accessed
+ */
+template <class T>
+inline void SetNoAccess(const T &value OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    VALGRIND_MAKE_MEM_NOACCESS(&value, sizeof(T));
+#endif
+}
+
+/*!
+ * \ingroup Valgrind
+ * \brief Make valgrind complain if the memory of a C-style array of
+ *        objects is accessed.
+ *
+ * Example:
+ *
+ * \code
+ * int i[3] = {0, 1, 2};
+ * Valgrind::SetNoAccess(i, 2);
+ * int j = i[1]; // Valgrind complains!
+ * \endcode
+ *
+ * \param value Pointer to the first object of the array.
+ * \param size The size of the array in number of objects
+ */
+template <class T>
+inline void SetNoAccess(const T *value OPM_VALGRIND_OPTIM_UNUSED, int size OPM_VALGRIND_OPTIM_UNUSED)
+{
+#if !defined NDEBUG && HAVE_VALGRIND
+    VALGRIND_MAKE_MEM_NOACCESS(value, size*sizeof(T));
+#endif
+}
+
+}} // namespace Valgrind, Opm
+
+#endif

opm/common/data/SimulationDataContainer.cpp

@@ -18,7 +18,7 @@
  */
 
 #include <opm/common/ErrorMacros.hpp>
-#include <opm/common/utility/numeric/cmp.hpp>
+#include <opm/common/util/numeric/cmp.hpp>
 #include <opm/common/data/SimulationDataContainer.hpp>
 
 namespace Opm {

opm/common/utility/numeric/MonotCubicInterpolator.hpp

@@ -1,583 +0,0 @@
-/* -*-C++-*- */
-
-#ifndef _MONOTCUBICINTERPOLATOR_H
-#define _MONOTCUBICINTERPOLATOR_H
-
-#include <vector>
-#include <map>
-#include <string>
-
-/*
-  MonotCubicInterpolator
-  Copyright (C) 2006 Statoil ASA
-
-  This program is free software; you can redistribute it and/or
-  modify it under the terms of the GNU General Public License
-  as published by the Free Software Foundation; either version 2
-  of the License, or (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-*/
-
-namespace Opm
-{
-
-/**
-   Class to represent a one-dimensional function f with single-valued
-   argument x. The function is represented by a table of function
-   values. Interpolation between table values is cubic and monotonicity
-   preserving if input values are monotonous.
-
-   Outside x_min and x_max, the class will extrapolate using the
-   constant f(x_min) or f(x_max).
-
-   Extra functionality:
-    - Can return (x_1+x_2)/2 where x_1 and x_2 are such that
-      abs(f(x_1) - f(x_2)) is maximized. This is used to determine where
-      one should calculate a new value for increased accuracy in the
-      current function
-
-   Monotonicity preserving cubic interpolation algorithm is taken
-   from Fritsch and Carlson, "Monotone piecewise cubic interpolation",
-   SIAM J. Numer. Anal. 17, 238--246, no. 2,
-
-   $Id$
-
-   Algorithm also described here:
-   http://en.wikipedia.org/wiki/Monotone_cubic_interpolation
-
-
-   @author Håvard Berland <havb (at) statoil.com>, December 2006
-   @brief Represents one dimensional function f with single valued argument x that can be interpolated using monotone cubic interpolation
-
-*/
-
-class MonotCubicInterpolator {
- public:
-
-   /**
-      @param datafilename A datafile with the x values and the corresponding f(x) values
-
-      Accepts a filename as input and parses this file for
-      two-column floating point data, interpreting the data as
-      representing function values x and f(x).
-
-      Ignores all lines not conforming to \<whitespace\>\<float\>\<whitespace\>\<float\>\<whatever\>\<newline\>
-   */
-  explicit MonotCubicInterpolator(const std::string & datafilename)
-  {
-    if (!read(datafilename)) {
-      throw("Unable to constuct MonotCubicInterpolator from file.") ;
-    } ;
-  }
-
-
-   /**
-      @param datafilename A datafile with the x values and the corresponding f(x) values
-
-      Accepts a filename as input and parses this file for
-      two-column floating point data, interpreting the data as
-      representing function values x and f(x).
-
-      Ignores all lines not conforming to \<whitespace\>\<float\>\<whitespace\>\<float\>\<whatever\>\<newline\>
-
-      All commas in the file will be treated as spaces when parsing.
-
-   */
-
- explicit MonotCubicInterpolator(const char* datafilename)
-  {
-    if (!read(std::string(datafilename))) {
-      throw("Unable to constuct MonotCubicInterpolator from file.") ;
-    } ;
-  }
-
-
-   /**
-       @param datafilename data file
-       @param XColumn x values
-       @param fColumn f values
-
-       Accepts a filename as input, and parses the chosen columns in
-       that file.
-   */
-   MonotCubicInterpolator(const char* datafilename, int xColumn, int fColumn)
-  {
-    if (!read(std::string(datafilename),xColumn,fColumn)) {
-      throw("Unable to constuct MonotCubicInterpolator from file.") ;
-    } ;
-  }
-
-   /**
-       @param datafilename data file
-       @param XColumn x values
-       @param fColumn f values
-
-       Accepts a filename as input, and parses the chosen columns in
-       that file.
-   */
-   MonotCubicInterpolator(const std::string & datafilename, int xColumn, int fColumn)
-  {
-    if (!read(datafilename,xColumn,fColumn)) {
-      throw("Unable to constuct MonotCubicInterpolator from file.") ;
-    } ;
-  }
-
-   /**
-      @param x vector of x values
-      @param f vector of corresponding f values
-
-      Accepts two equal-length vectors as input for constructing
-      the interpolation object.  First vector is the x-values, the
-      second vector is the function values
-   */
-     MonotCubicInterpolator(const std::vector<double> & x ,
-                            const std::vector<double> & f);
-
-   /**
-      No input, an empty function object is created.
-
-      This object must be treated with care until
-      populated.
-   */
-   MonotCubicInterpolator() { }
-
-
-
-   /**
-      @param datafilename A datafile with the x values and the corresponding f(x) values
-
-      Accepts a filename as input and parses this file for
-      two-column floating point data, interpreting the data as
-      representing function values x and f(x).
-
-      returns true on success
-
-      All commas in file will be treated as spaces when parsing
-
-      Ignores all lines not conforming to \<whitespace\>\<float\>\<whitespace\>\<float\>\<whatever\>\<newline\>
-   */
-  bool read(const std::string & datafilename) {
-    return read(datafilename,1,2) ;
-  }
-
-   /**
-       @param datafilename data file
-       @param XColumn x values
-       @param fColumn f values
-
-       Accepts a filename as input, and parses the chosen columns in
-       that file.
-   */
-  bool read(const std::string &  datafilename, int xColumn, int fColumn) ;
-
-
-
-   /**
-      @param x x value
-
-      Returns f(x) for given x (input). Interpolates (monotone cubic
-      or linearly) if necessary.
-
-      Extrapolates using the constants f(x_min) or f(x_max) if
-      input x is outside (x_min, x_max)
-
-      @return f(x) for a given x
-   */
-  double operator () (double x) const { return evaluate(x) ; }
-
-   /**
-      @param x x value
-
-      Returns f(x) for given x (input). Interpolates (monotone cubic
-      or linearly) if necessary.
-
-      Extrapolates using the constants f(x_min) or f(x_max) if
-      input x is outside (x_min, x_max)
-
-      @return f(x) for a given x
-   */
-   double evaluate(double x) const;
-
-   /**
-      @param x x value
-      @param errorestimate_output
-
-      Returns f(x) and an error estimate for given x (input).
-
-      Interpolates (linearly) if necessary.
-
-      Throws an exception if extrapolation would be necessary for
-      evaluation. We do not want to do extrapolation (yet).
-
-      The error estimate for x1 < x < x2 is
-      (x2 - x1)^2/8 * f''(x) where f''(x) is evaluated using
-      the stencil (1 -2  1) using either (x0, x1, x2) or (x1, x2, x3);
-
-      Throws an exception if the table contains only two x-values.
-
-      NOT IMPLEMENTED YET!
-   */
-   double evaluate(double x, double & errorestimate_output ) const ;
-
-   /**
-      Minimum x-value, returns both x and f in a pair.
-
-      @return minimum x value
-      @return f(minimum x value)
-   */
-   std::pair<double,double> getMinimumX() const {
-       // Easy since the data is sorted on x:
-       return *data.begin();
-   }
-
-   /**
-      Maximum x-value, returns both x and f in a pair.
-
-      @return maximum x value
-      @return f(maximum x value)
-   */
-   std::pair<double,double> getMaximumX() const {
-       // Easy since the data is sorted on x:
-       return *data.rbegin();
-   }
-
-   /**
-      Maximum f-value, returns both x and f in a pair.
-
-      @return x value corresponding to maximum f value
-      @return maximum f value
-   */
-   std::pair<double,double> getMaximumF() const ;
-
-   /**
-      Minimum f-value, returns both x and f in a pair
-
-      @return x value corresponding to minimal f value
-      @return minimum f value
-   */
-   std::pair<double,double> getMinimumF() const  ;
-
-
-   /**
-      Provide a copy of the x-data as a vector
-
-      Unspecified order, but corresponds to get_fVector.
-
-      @return x values as a vector
-   */
-   std::vector<double> get_xVector() const ;
-
-   /**
-      Provide a copy of tghe function data as a vector
-
-      Unspecified order, but corresponds to get_xVector
-
-      @return f values as a vector
-
-   */
-   std::vector<double> get_fVector() const ;
-
-   /**
-      @param factor Scaling constant
-
-      Scale all the function value data by a constant
-   */
-   void scaleData(double factor);
-
-   /**
-      Determines if the current function-value-data is strictly
-      monotone. This is a utility function for outsiders if they want
-      to invert the data for example.
-
-      @return True if f(x) is strictly monotone, else False
-   */
-   bool isStrictlyMonotone() {
-
-       /* Use cached value if it can be trusted */
-       if (strictlyMonotoneCached) {
-           return strictlyMonotone;
-       }
-       else {
-           computeInternalFunctionData();
-           return strictlyMonotone;
-       }
-   }
-
-   /**
-      Determines if the current function-value-data is monotone.
-
-      @return True if f(x) is monotone, else False
-   */
-   bool isMonotone() const {
-       if (monotoneCached) {
-           return monotone;
-       }
-       else {
-           computeInternalFunctionData();
-           return monotone;
-       }
-   }
-   /**
-      Determines if the current function-value-data is strictly
-      increasing. This is a utility function for outsiders if they want
-      to invert the data for example.
-
-      @return True if f(x) is strictly increasing, else False
-   */
-   bool isStrictlyIncreasing() {
-
-       /* Use cached value if it can be trusted */
-       if (strictlyMonotoneCached) {
-           return (strictlyMonotone && strictlyIncreasing);
-       }
-       else {
-           computeInternalFunctionData();
-           return (strictlyMonotone && strictlyIncreasing);
-       }
-   }
-
-   /**
-      Determines if the current function-value-data is monotone and increasing.
-
-      @return True if f(x) is monotone and increasing, else False
-   */
-   bool isMonotoneIncreasing() const {
-       if (monotoneCached) {
-           return (monotone && increasing);
-       }
-       else {
-           computeInternalFunctionData();
-           return (monotone && increasing);
-       }
-   }
-   /**
-      Determines if the current function-value-data is strictly
-      decreasing. This is a utility function for outsiders if they want
-      to invert the data for example.
-
-      @return True if f(x) is strictly decreasing, else False
-   */
-   bool isStrictlyDecreasing() {
-
-       /* Use cached value if it can be trusted */
-       if (strictlyMonotoneCached) {
-           return (strictlyMonotone && strictlyDecreasing);
-       }
-       else {
-           computeInternalFunctionData();
-           return (strictlyMonotone && strictlyDecreasing);
-       }
-   }
-
-   /**
-      Determines if the current function-value-data is monotone and decreasing
-
-      @return True if f(x) is monotone and decreasing, else False
-   */
-   bool isMonotoneDecreasing() const {
-       if (monotoneCached) {
-           return (monotone && decreasing);
-       }
-       else {
-           computeInternalFunctionData();
-           return (monotone && decreasing);
-       }
-   }
-
-
-
-   /**
-      @param newx New x point
-      @param newf New f(x) point
-
-      Adds a new datapoint to the function.
-
-      This causes all the derivatives at all points of the functions
-      to be recomputed and then adjusted for monotone cubic
-      interpolation. If this function ever enters a critical part of
-      any code, the locality of the algorithm for monotone adjustment
-      must be exploited.
-
-   */
-   void addPair(double newx, double newf);
-
-   /**
-      Returns an x-value that is believed to yield the best
-      improvement in global accuracy for the interpolation if
-      computed.
-
-      Searches for the largest jump in f-values, and returns a x
-      value being the average of the two x-values representing the
-      f-value-jump.
-
-      @return New x value beleived to yield the best improvement in global accuracy
-      @return Maximal difference
-   */
-   std::pair<double,double> getMissingX() const;
-
-   /**
-      Constructs a string containing the data in a table
-
-      @return a string containing the data in a table
-   */
-   std::string toString() const;
-
-   /**
-     @return Number of datapoint pairs in this object
-   */
-   int getSize() const {
-       return data.size();
-   }
-
-    /**
-       Checks if the function curve is flat at the endpoints, chop off
-       endpoint data points if that is the case.
-
-       The notion of "flat" is determined by the input parameter "epsilon"
-       Values whose difference are less than epsilon are regarded as equal.
-
-       This is implemented to be able to obtain a strictly monotone
-       curve from a data set that is strictly monotone except at the
-       endpoints.
-
-       Example:
-         The data points
-            (1,3), (2,3), (3,4), (4,5), (5,5), (6,5)
-         will become
-            (2,3), (3,4), (4,5)
-
-       Assumes at least 3 datapoints. If less than three, this function is a noop.
-    */
-    void chopFlatEndpoints(const double);
-
-    /**
-       Wrapper function for chopFlatEndpoints(const double)
-       providing a default epsilon parameter
-    */
-    void chopFlatEndpoints() {
-        chopFlatEndpoints(1e-14);
-    }
-
-    /**
-       If function is monotone, but not strictly monotone,
-       this function will remove datapoints from intervals
-       with zero derivative so that the curve become
-       strictly monotone.
-
-       Example
-         The data points
-           (1,2), (2,3), (3,4), (4,4), (5,5), (6,6)
-         will become
-           (1,2), (2,3), (3,4), (5,5), (6,6)
-
-       Assumes at least two datapoints, if one or zero datapoint, this is a noop.
-    */
-    void shrinkFlatAreas(const double);
-
-    /**
-       Wrapper function for shrinkFlatAreas(const double)
-       providing a default epsilon parameter
-    */
-    void shrinkFlatAreas() {
-        shrinkFlatAreas(1e-14);
-    }
-
-
-
-private:
-
-   // Data structure to store x- and f-values
-   std::map<double, double> data;
-
-   // Data structure to store x- and d-values
-   mutable std::map<double, double> ddata;
-
-
-   // Storage containers for precomputed interpolation data
-   //   std::vector<double> dvalues; // derivatives in Hermite interpolation.
-
-   // Flag to determine whether the boolean strictlyMonotone can be
-   // trusted.
-   mutable bool strictlyMonotoneCached;
-   mutable bool monotoneCached; /* only monotone, not stricly montone */
-
-   mutable bool strictlyMonotone;
-   mutable bool monotone;
-
-   // if strictlyMonotone is true (and can be trusted), the two next are meaningful
-   mutable bool strictlyDecreasing;
-   mutable bool strictlyIncreasing;
-   mutable bool decreasing;
-   mutable bool increasing;
-
-
-   /* Hermite basis functions, t \in [0,1] ,
-      notation from:
-      http://en.wikipedia.org/w/index.php?title=Cubic_Hermite_spline&oldid=84495502
-   */
-
-   double H00(double t) const {
-       return 2*t*t*t - 3*t*t + 1;
-   }
-   double H10(double t) const {
-       return t*t*t - 2*t*t + t;
-   }
-   double H01(double t) const {
-       return -2*t*t*t + 3*t*t;
-   }
-   double H11(double t) const {
-       return t*t*t - t*t;
-   }
-
-
-   void computeInternalFunctionData() const ;
-
-   /**
-       Computes initial derivative values using centered (second order) difference
-       for internal datapoints, and one-sided derivative for endpoints
-
-       The internal datastructure map<double,double> ddata is populated by this method.
-   */
-
-   void computeSimpleDerivatives() const ;
-
-
-   /**
-      Adjusts the derivative values (ddata) so that we can guarantee that
-      the resulting piecewise Hermite polymial is monotone. This is
-      done according to the algorithm of Fritsch and Carlsson 1980,
-      see Section 4, especially the two last lines.
-   */
-  void adjustDerivativesForMonotoneness() const ;
-
-   /**
-       Checks if the coefficient alpha and beta is in
-       the region that guarantees monotoneness of the
-       derivative values they represent
-
-       See Fritsch and Carlson 1980, Lemma 2,
-       alternatively Step 5 in Wikipedia's article
-       on Monotone cubic interpolation.
-   */
-   bool isMonotoneCoeff(double alpha, double beta) const {
-       if ((alpha*alpha + beta*beta) <= 9) {
-         return true;
-       } else {
-         return false;
-       }
-   }
-
-};
-
-
-} // namespace Opm
-
-#endif

opm/common/utility/numeric/NonuniformTableLinear.hpp

@@ -1,208 +0,0 @@
-/*
-  Copyright 2009, 2010, 2011, 2012 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010, 2011, 2012 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_NONUNIFORMTABLELINEAR_HEADER_INCLUDED
-#define OPM_NONUNIFORMTABLELINEAR_HEADER_INCLUDED
-
-#include <cmath>
-#include <exception>
-#include <vector>
-#include <utility>
-
-#include <opm/common/ErrorMacros.hpp>
-#include <opm/common/utility/numeric/linearInterpolation.hpp>
-
-
-namespace Opm
-{
-
-
-    /// @brief This class uses linear interpolation to compute the value
-    ///        (and its derivative) of a function f sampled at possibly
-    ///         nonuniform points. If values outside the domain are sought,
-    ///         values will be extrapolated linearly.
-    /// @tparam T the range type of the function (should be an algebraic ring type)
-    template<typename T>
-    class NonuniformTableLinear
-    {
-    public:
-        /// @brief Default constructor.
-        NonuniformTableLinear();
-
-        /// @brief Construct from vectors of x and y values.
-        /// @param x_values vector of domain values
-        /// @param y_values vector of corresponding range values.
-        template<class XContainer, class YContainer>
-        NonuniformTableLinear(const XContainer& x_values,
-                              const YContainer& y_values);
-
-        /// @brief Get the domain.
-        /// @return the domain as a pair of doubles.
-        std::pair<double, double> domain();
-
-        /// @brief Rescale the domain.
-        /// @param new_domain the new domain as a pair of doubles.
-        void rescaleDomain(std::pair<double, double> new_domain);
-
-        /// @brief Evaluate the value at x.
-        /// @param x a domain value
-        /// @return f(x)
-        double operator()(const double x) const;
-
-        /// @brief Evaluate the derivative at x.
-        /// @param x a domain value
-        /// @return f'(x)
-        double derivative(const double x) const;
-
-        /// @brief Evaluate the inverse at y. Requires T to be a double.
-        /// @param y a range value
-        /// @return f^{-1}(y)
-        double inverse(const double y) const;
-
-        /// @brief Equality operator.
-        /// @param other another NonuniformTableLinear.
-        /// @return true if they are represented exactly alike.
-        bool operator==(const NonuniformTableLinear& other) const;
-
-    protected:
-        std::vector<double> x_values_;
-        std::vector<T> y_values_;
-        mutable std::vector<T> x_values_reversed_;
-        mutable std::vector<T> y_values_reversed_;
-    };
-
-
-    // A utility function
-    /// @brief Detect if a sequence is nondecreasing.
-    /// @tparam FI a forward iterator whose value type has operator< defined.
-    /// @param beg start of sequence
-    /// @param end one-beyond-end of sequence
-    /// @return false if there exists two consecutive values (v1, v2) in the sequence
-    ///         for which v2 < v1, else returns true.
-    template <typename FI>
-    bool isNondecreasing(const FI beg, const FI end)
-    {
-        if (beg == end) return true;
-        FI it = beg;
-        ++it;
-        FI prev = beg;
-        for (; it != end; ++it, ++prev) {
-            if (*it < *prev) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-
-
-    // Member implementations.
-
-    template<typename T>
-    inline
-    NonuniformTableLinear<T>
-    ::NonuniformTableLinear()
-    {
-    }
-
-
-    template<typename T>
-    template<class XContainer, class YContainer>
-    inline
-    NonuniformTableLinear<T>
-    ::NonuniformTableLinear(const XContainer& x_column,
-                            const YContainer& y_column)
-        : x_values_( x_column.begin() , x_column.end()),
-          y_values_( y_column.begin() , y_column.end())
-    {
-        assert(isNondecreasing(x_values_.begin(), x_values_.end()));
-    }
-
-
-    template<typename T>
-    inline std::pair<double, double>
-    NonuniformTableLinear<T>
-    ::domain()
-    {
-        return std::make_pair(x_values_[0], x_values_.back());
-    }
-
-    template<typename T>
-    inline void
-    NonuniformTableLinear<T>
-    ::rescaleDomain(std::pair<double, double> new_domain)
-    {
-        const double a = x_values_[0];
-        const double b = x_values_.back();
-        const double c = new_domain.first;
-        const double d = new_domain.second;
-        // x in [a, b] -> x in [c, d]
-        for (int i = 0; i < int(x_values_.size()); ++i) {
-            x_values_[i] = (x_values_[i] - a)*(d - c)/(b - a) + c;
-        }
-    }
-
-    template<typename T>
-    inline double
-    NonuniformTableLinear<T>
-    ::operator()(const double x) const
-    {
-        return Opm::linearInterpolation(x_values_, y_values_, x);
-    }
-
-    template<typename T>
-    inline double
-    NonuniformTableLinear<T>
-    ::derivative(const double x) const
-    {
-        return Opm::linearInterpolationDerivative(x_values_, y_values_, x);
-    }
-
-    template<typename T>
-    inline double
-    NonuniformTableLinear<T>
-    ::inverse(const double y) const
-    {
-        if (y_values_.front() < y_values_.back()) {
-            return Opm::linearInterpolation(y_values_, x_values_, y);
-        } else {
-            if (y_values_reversed_.empty()) {
-                y_values_reversed_ = y_values_;
-                std::reverse(y_values_reversed_.begin(), y_values_reversed_.end());
-                assert(isNondecreasing(y_values_reversed_.begin(), y_values_reversed_.end()));
-                x_values_reversed_ = x_values_;
-                std::reverse(x_values_reversed_.begin(), x_values_reversed_.end());
-            }
-            return Opm::linearInterpolation(y_values_reversed_, x_values_reversed_, y);
-        }
-    }
-
-    template<typename T>
-    inline bool
-    NonuniformTableLinear<T>
-    ::operator==(const NonuniformTableLinear<T>& other) const
-    {
-        return x_values_ == other.x_values_
-            && y_values_ == other.y_values_;
-    }
-
-} // namespace Opm
-
-#endif // OPM_NONUNIFORMTABLELINEAR_HEADER_INCLUDED

opm/common/utility/numeric/RootFinders.hpp

@@ -1,340 +0,0 @@
-//===========================================================================
-//
-// File: RootFinders.hpp
-//
-// Created: Thu May  6 19:59:42 2010
-//
-// Author(s): Atgeirr F Rasmussen <atgeirr@sintef.no>
-//            Jostein R Natvig    <jostein.r.natvig@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_ROOTFINDERS_HEADER
-#define OPM_ROOTFINDERS_HEADER
-
-#include <opm/common/ErrorMacros.hpp>
-
-#include <algorithm>
-#include <limits>
-#include <cmath>
-#include <iostream>
-
-namespace Opm
-{
-
-    struct ThrowOnError
-    {
-        static double handleBracketingFailure(const double x0, const double x1, const double f0, const double f1)
-        {
-            OPM_THROW(std::runtime_error, "Error in parameters, zero not bracketed: [a, b] = ["
-                  << x0 << ", " << x1 << "]    f(a) = " << f0 << "   f(b) = " << f1);
-            return -1e100; // Never reached.
-        }
-        static double handleTooManyIterations(const double x0, const double x1, const int maxiter)
-        {
-            OPM_THROW(std::runtime_error, "Maximum number of iterations exceeded: " << maxiter << "\n"
-                  << "Current interval is [" << std::min(x0, x1) << ", "
-                  << std::max(x0, x1) << "]");
-            return -1e100; // Never reached.
-        }
-    };
-
-
-    struct WarnAndContinueOnError
-    {
-        static double handleBracketingFailure(const double x0, const double x1, const double f0, const double f1)
-        {
-            OPM_REPORT;
-            std::cerr << "Error in parameters, zero not bracketed: [a, b] = ["
-                      << x0 << ", " << x1 << "]    f(a) = " << f0 << "   f(b) = " << f1
-                      << "";
-            return std::fabs(f0) < std::fabs(f1) ? x0 : x1;
-        }
-        static double handleTooManyIterations(const double x0, const double x1, const int maxiter)
-        {
-            OPM_REPORT;
-            std::cerr << "Maximum number of iterations exceeded: " << maxiter
-                      << ", current interval is [" << std::min(x0, x1) << ", "
-                      << std::max(x0, x1) << "]";
-            return 0.5*(x0 + x1);
-        }
-    };
-
-
-    struct ContinueOnError
-    {
-        static double handleBracketingFailure(const double x0, const double x1, const double f0, const double f1)
-        {
-            return std::fabs(f0) < std::fabs(f1) ? x0 : x1;
-        }
-        static double handleTooManyIterations(const double x0, const double x1, const int /*maxiter*/)
-        {
-            return 0.5*(x0 + x1);
-        }
-    };
-
-
-
-    template <class ErrorPolicy = ThrowOnError>
-    class RegulaFalsi
-    {
-    public:
-
-
-        /// Implements a modified regula falsi method as described in
-        /// "Improved algorithms of Illinois-type for the numerical
-        /// solution of nonlinear equations"
-        /// by J. A. Ford.
-        /// Current variant is the 'Pegasus' method.
-        template <class Functor>
-        inline static double solve(const Functor& f,
-                                   const double a,
-                                   const double b,
-                                   const int max_iter,
-                                   const double tolerance,
-                                   int& iterations_used)
-        {
-            using namespace std;
-            const double macheps = numeric_limits<double>::epsilon();
-            const double eps = tolerance + macheps*max(max(fabs(a), fabs(b)), 1.0);
-
-            double x0 = a;
-            double x1 = b;
-            double f0 = f(x0);
-            const double epsF = tolerance + macheps*max(fabs(f0), 1.0);
-            if (fabs(f0) < epsF) {
-                return x0;
-            }
-            double f1 = f(x1);
-            if (fabs(f1) < epsF) {
-                return x1;
-            }
-            if (f0*f1 > 0.0) {
-                return ErrorPolicy::handleBracketingFailure(a, b, f0, f1);
-            }
-            iterations_used = 0;
-            // In every iteraton, x1 is the last point computed,
-            // and x0 is the last point computed that makes it a bracket.
-            while (fabs(x1 - x0) >= 1e-9*eps) {
-                double xnew = regulaFalsiStep(x0, x1, f0, f1);
-                double fnew = f(xnew);
-// 		cout << "xnew = " << xnew << "    fnew = " << fnew << endl;
-                ++iterations_used;
-                if (iterations_used > max_iter) {
-                    return ErrorPolicy::handleTooManyIterations(x0, x1, max_iter);
-                }
-                if (fabs(fnew) < epsF) {
-                    return xnew;
-                }
-                // Now we must check which point we must replace.
-                if ((fnew > 0.0) == (f0 > 0.0)) {
-                    // We must replace x0.
-                    x0 = x1;
-                    f0 = f1;
-                } else {
-                    // We must replace x1, this is the case where
-                    // the modification to regula falsi kicks in,
-                    // by modifying f0.
-                    // 1. The classic Illinois method
-//                  const double gamma = 0.5;
-                    // @afr: The next two methods do not work??!!?
-                    // 2. The method called 'Method 3' in the paper.
-//                  const double phi0 = f1/f0;
-//                  const double phi1 = fnew/f1;
-//                  const double gamma = 1.0 - phi1/(1.0 - phi0);
-                    // 3. The method called 'Method 4' in the paper.
-//                  const double phi0 = f1/f0;
-//                  const double phi1 = fnew/f1;
-//                  const double gamma = 1.0 - phi0 - phi1;
-//                  cout << "phi0 = " << phi0 <<" phi1 = " << phi1 <<
-//                  " gamma = " << gamma << endl;
-                    // 4. The 'Pegasus' method
-                    const double gamma = f1/(f1 + fnew);
-                    f0 *= gamma;
-                }
-                x1 = xnew;
-                f1 = fnew;
-            }
-            return 0.5*(x0 + x1);
-        }
-
-
-        /// Implements a modified regula falsi method as described in
-        /// "Improved algorithms of Illinois-type for the numerical
-        /// solution of nonlinear equations"
-        /// by J. A. Ford.
-        /// Current variant is the 'Pegasus' method.
-        /// This version takes an extra parameter for the initial guess.
-        template <class Functor>
-        inline static double solve(const Functor& f,
-                                   const double initial_guess,
-                                   const double a,
-                                   const double b,
-                                   const int max_iter,
-                                   const double tolerance,
-                                   int& iterations_used)
-        {
-            using namespace std;
-            const double macheps = numeric_limits<double>::epsilon();
-            const double eps = tolerance + macheps*max(max(fabs(a), fabs(b)), 1.0);
-
-            double f_initial = f(initial_guess);
-            const double epsF = tolerance + macheps*max(fabs(f_initial), 1.0);
-            if (fabs(f_initial) < epsF) {
-                return initial_guess;
-            }
-            double x0 = a;
-            double x1 = b;
-            double f0 = f_initial;
-            double f1 = f_initial;
-            if (x0 != initial_guess) {
-                f0 = f(x0);
-                if (fabs(f0) < epsF) {
-                    return x0;
-                }
-            }
-            if (x1 != initial_guess) {
-                f1 = f(x1);
-                if (fabs(f1) < epsF) {
-                    return x1;
-                }
-            }
-            if (f0*f_initial < 0.0) {
-                x1 = initial_guess;
-                f1 = f_initial;
-            } else {
-                x0 = initial_guess;
-                f0 = f_initial;
-            }
-            if (f0*f1 > 0.0) {
-                return ErrorPolicy::handleBracketingFailure(a, b, f0, f1);
-            }
-            iterations_used = 0;
-            // In every iteraton, x1 is the last point computed,
-            // and x0 is the last point computed that makes it a bracket.
-            while (fabs(x1 - x0) >= 1e-9*eps) {
-                double xnew = regulaFalsiStep(x0, x1, f0, f1);
-                double fnew = f(xnew);
-// 		cout << "xnew = " << xnew << "    fnew = " << fnew << endl;
-                ++iterations_used;
-                if (iterations_used > max_iter) {
-                    return ErrorPolicy::handleTooManyIterations(x0, x1, max_iter);
-                }
-                if (fabs(fnew) < epsF) {
-                    return xnew;
-                }
-                // Now we must check which point we must replace.
-                if ((fnew > 0.0) == (f0 > 0.0)) {
-                    // We must replace x0.
-                    x0 = x1;
-                    f0 = f1;
-                } else {
-                    // We must replace x1, this is the case where
-                    // the modification to regula falsi kicks in,
-                    // by modifying f0.
-                    // 1. The classic Illinois method
-//      const double gamma = 0.5;
-                    // @afr: The next two methods do not work??!!?
-                    // 2. The method called 'Method 3' in the paper.
-// 		    const double phi0 = f1/f0;
-// 		    const double phi1 = fnew/f1;
-// 		    const double gamma = 1.0 - phi1/(1.0 - phi0);
-                    // 3. The method called 'Method 4' in the paper.
-// 		    const double phi0 = f1/f0;
-// 		    const double phi1 = fnew/f1;
-// 		    const double gamma = 1.0 - phi0 - phi1;
-// 		    cout << "phi0 = " << phi0 <<" phi1 = " << phi1 <<
-// 		    " gamma = " << gamma << endl;
-                    // 4. The 'Pegasus' method
-                    const double gamma = f1/(f1 + fnew);
-                    f0 *= gamma;
-                }
-                x1 = xnew;
-                f1 = fnew;
-            }
-            return 0.5*(x0 + x1);
-        }
-
-
-    private:
-        inline static double regulaFalsiStep(const double a,
-                                             const double b,
-                                             const double fa,
-                                             const double fb)
-        {
-            assert(fa*fb < 0.0);
-            return (b*fa - a*fb)/(fa - fb);
-        }
-
-
-    };
-
-
-
-    /// Attempts to find an interval bracketing a zero by successive
-    /// enlargement of search interval.
-    template <class Functor>
-    inline void bracketZero(const Functor& f,
-                            const double x0,
-                            const double dx,
-                            double& a,
-                            double& b)
-    {
-        const int max_iters = 100;
-        double f0 = f(x0);
-        double cur_dx = dx;
-        int i = 0;
-        for (; i < max_iters; ++i) {
-            double x = x0 + cur_dx;
-            double f_new = f(x);
-            if (f0*f_new <= 0.0) {
-                break;
-            }
-            cur_dx = -2.0*cur_dx;
-        }
-        if (i == max_iters) {
-            OPM_THROW(std::runtime_error, "Could not bracket zero in " << max_iters << "iterations.");
-        }
-        if (cur_dx < 0.0) {
-            a = x0 + cur_dx;
-            b = i < 2 ? x0 : x0 + 0.25*cur_dx;
-        } else {
-            a = i < 2 ? x0 : x0 + 0.25*cur_dx;
-            b = x0 + cur_dx;
-        }
-    }
-
-
-
-
-
-} // namespace Opm
-
-
-
-
-#endif // OPM_ROOTFINDERS_HEADER

opm/common/utility/numeric/SparseVector.hpp

@@ -1,198 +0,0 @@
-//===========================================================================
-//
-// File: SparseVector.hpp
-//
-// Created: Mon Jun 29 15:28:59 2009
-//
-// Author(s): Atgeirr F Rasmussen <atgeirr@sintef.no>
-//            B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef OPM_SPARSEVECTOR_HEADER
-#define OPM_SPARSEVECTOR_HEADER
-
-#include <vector>
-#include <numeric>
-#include <algorithm>
-#include <opm/common/ErrorMacros.hpp>
-
-namespace Opm
-{
-
-    /// A SparseVector stores a vector with possibly many empty elements
-    /// as efficiently as possible.
-    /// It is supposed to behave similarly to a standard vector, but since
-    /// direct indexing is a O(log n) operation instead of O(1), we do not
-    /// supply it as operator[].
-    template <typename T>
-    class SparseVector
-    {
-    public:
-	/// Default constructor. Yields an empty SparseVector.
-	SparseVector()
-	    : size_(0), default_elem_()
-	{
-	}
-
-	/// Constructs a SparseVector with a given size, but no nonzero
-	/// elements.
-	explicit SparseVector(int sz)
-	    : size_(sz), default_elem_()
-	{
-	}
-
-	/// A constructor taking all the element data for the vector and their indices.
-	/// \param data_beg The start of the element data.
-	/// \param data_end One-beyond-end of the element data.
-	/// \param rowsize_beg The start of the index data.
-	/// \param rowsize_end One beyond the end of the index data.
-	template <typename DataIter, typename IntegerIter>
-	SparseVector(int sz,
-		     DataIter data_beg, DataIter data_end,
-		     IntegerIter index_beg, IntegerIter index_end)
-	    : size_(sz), data_(data_beg, data_end), indices_(index_beg, index_end),
-	      default_elem_()
-	{
-#ifndef NDEBUG
-	    OPM_ERROR_IF(sz < 0, "The size of a SparseVector must be non-negative");
-	    OPM_ERROR_IF(indices_.size() != data_.size(), "The number of indices of a SparseVector must equal to the number of entries");
-	    int last_index = -1;
-	    int num_ind = indices_.size();
-	    for (int i = 0; i < num_ind; ++i) {
-		int index = indices_[i];
-		if (index <= last_index || index >= sz) {
-		    OPM_THROW(std::logic_error, "Error in SparseVector construction, index is nonincreasing or out of range.");
-		}
-		last_index = index;
-	    }
-#endif
-	}
-
-
-	/// Appends an element to the vector. Note that this function does not
-	/// increase the size() of the vector, it just adds another nonzero element.
-	/// Elements must be added in index order.
-	void addElement(const T& elem, int index)
-	{
-	    assert(indices_.empty() || index > indices_.back());
-	    assert(index < size_);
-	    data_.push_back(elem);
-	    indices_.push_back(index);
-	}
-
-	/// \return true if the vector has size 0.
-	bool empty() const
-	{
-	    return size_ == 0;
-	}
-
-	/// Returns the size of the vector.
-	/// Recall that most or all of the vector may be default/zero.
-	int size() const
-	{
-	    return size_;
-	}
-
-	/// Returns the number of nonzero data elements.
-	int nonzeroSize() const
-	{
-	    return data_.size();
-	}
-
-	/// Makes the vector empty().
-	void clear()
-	{
-	    data_.clear();
-	    indices_.clear();
-	    size_ = 0;
-	}
-
-	/// Equality.
-	bool operator==(const SparseVector& other) const
-	{
-	    return size_ == other.size_ && data_ == other.data_ && indices_ == other.indices_;
-	}
-
-	/// O(log n) element access.
-	/// \param index the proper vector index
-	/// \return the element with the given index, or the default element if no element in
-	/// the vector has the given index.
-	const T& element(int index) const
-	{
-#ifndef NDEBUG
-	    OPM_ERROR_IF(index < 0, "The index of a SparseVector must be non-negative (is " << index << ")");
-	    OPM_ERROR_IF(index >= size_, "The index of a SparseVector must be smaller than the maximum value (is " << index << ", max value: " << size_ <<")");
-#endif
-	    std::vector<int>::const_iterator lb = std::lower_bound(indices_.begin(), indices_.end(), index);
-	    if (lb != indices_.end() && *lb == index) {
-		return data_[lb - indices_.begin()];
-	    } else {
-		return default_elem_;
-	    }
-	}
-
-	/// O(1) element access.
-	/// \param nzindex an index counting only nonzero elements.
-	/// \return the nzindex'th nonzero element.
-	const T& nonzeroElement(int nzindex) const
-	{
-#ifndef NDEBUG
-	    OPM_ERROR_IF(nzindex < 0, "The index of a SparseVector must be non-negative (is " << nzindex << ")");
-	    OPM_ERROR_IF(nzindex >= nonzeroSize(), "The index of a SparseVector must be smaller than the maximum value (is " << nzindex << ", max value: " << nonzeroSize() <<")");
-#endif
-	    return data_[nzindex];
-	}
-
-	/// O(1) index access.
-	/// \param nzindex an index counting only nonzero elements.
-	/// \return the index of the nzindex'th nonzero element.
-	int nonzeroIndex(int nzindex) const
-	{
-	    assert(nzindex >= 0);
-	    assert(nzindex < nonzeroSize());
-	    return indices_[nzindex];
-	}
-
-    private:
-	// The vectors data_ and indices_ are always the same size.
-	// The indices are supposed to be stored in increasing order,
-	// to be unique, and to be in [0, size_ - 1].
-	// default_elem_ is returned when a default element is requested.
-	int size_;
-	std::vector<T> data_;
-	std::vector<int> indices_;
-	T default_elem_;
-    };
-
-} // namespace Opm
-
-
-
-
-#endif // OPM_SPARSEVECTOR_HEADER

opm/common/utility/numeric/UniformTableLinear.hpp

@@ -1,268 +0,0 @@
-/*
-  Copyright 2010 SINTEF ICT, Applied Mathematics.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_UNIFORMTABLELINEAR_HEADER_INCLUDED
-#define OPM_UNIFORMTABLELINEAR_HEADER_INCLUDED
-
-#include <cmath>
-#include <exception>
-#include <vector>
-#include <utility>
-#include <iostream>
-
-#include <opm/common/ErrorMacros.hpp>
-
-namespace Opm {
-
-	/// @brief This class uses linear interpolation to compute the value
-	///        (and its derivative) of a function f sampled at uniform points.
-	/// @tparam T the range type of the function (should be an algebraic ring type)
-	template<typename T>
-	class UniformTableLinear
-	{
-	public:
-	    /// @brief Default constructor.
-	    UniformTableLinear();
-
-	    /// @brief Construct from vector of y-values.
-	    /// @param xmin the x value corresponding to the first y value.
-	    /// @param xmax the x value corresponding to the last y value.
-	    /// @param y_values vector of range values.
-	    UniformTableLinear(double xmin,
-                               double xmax,
-                               const std::vector<T>& y_values);
-
-	    /// @brief Construct from array of y-values.
-	    /// @param xmin the x value corresponding to the first y value.
-	    /// @param xmax the x value corresponding to the last y value.
-	    /// @param y_values array of range values.
-            /// @param num_y_values the number of values in y_values.
-	    UniformTableLinear(double xmin,
-                               double xmax,
-                               const T* y_values,
-                               int num_y_values);
-
-	    /// @brief Get the domain.
-	    /// @return the domain as a pair of doubles.
-	    std::pair<double, double> domain();
-
-	    /// @brief Rescale the domain.
-	    /// @param new_domain the new domain as a pair of doubles.
-	    void rescaleDomain(std::pair<double, double> new_domain);
-
-	    /// @brief Evaluate the value at x.
-	    /// @param x a domain value
-	    /// @return f(x)
-	    double operator()(const double x) const;
-
-	    /// @brief Evaluate the derivative at x.
-	    /// @param x a domain value
-	    /// @return f'(x)
-	    double derivative(const double x) const;
-
-	    /// @brief Equality operator.
-	    /// @param other another UniformTableLinear.
-	    /// @return true if they are represented exactly alike.
-	    bool operator==(const UniformTableLinear& other) const;
-
-	    /// @brief Policies for how to behave when trying to evaluate outside the domain.
-	    enum RangePolicy {Throw = 0, ClosestValue = 1, Extrapolate = 2};
-
-	    /// @brief Sets the behavioural policy for evaluation to the left of the domain.
-	    /// @param rp the policy
-	    void setLeftPolicy(RangePolicy rp);
-
-	    /// @brief Sets the behavioural policy for evaluation to the right of the domain.
-	    /// @param rp the policy
-	    void setRightPolicy(RangePolicy rp);
-
-	protected:
-            double xmin_;
-            double xmax_;
-            double xdelta_;
-	    std::vector<T> y_values_;
-	    RangePolicy left_;
-	    RangePolicy right_;
-            template <typename U>
-            friend std::ostream& operator<<(std::ostream& os, const UniformTableLinear<U>& t);
-	};
-
-
-	// Member implementations.
-
-	template<typename T>
-	inline
-	UniformTableLinear<T>
-	::UniformTableLinear()
-	    : left_(ClosestValue), right_(ClosestValue)
-	{
-	}
-
-	template<typename T>
-	inline
-	UniformTableLinear<T>
-	::UniformTableLinear(double xmin,
-                             double xmax,
-                             const std::vector<T>& y_values)
-	    : xmin_(xmin), xmax_(xmax), y_values_(y_values),
-	      left_(ClosestValue), right_(ClosestValue)
-	{
-            assert(xmax > xmin);
-            assert(y_values.size() > 1);
-            xdelta_ = (xmax - xmin)/(y_values.size() - 1);
-	}
-
-	template<typename T>
-	inline
-	UniformTableLinear<T>
-	::UniformTableLinear(double xmin,
-                             double xmax,
-                             const T* y_values,
-                             int num_y_values)
-	    : xmin_(xmin), xmax_(xmax),
-              y_values_(y_values, y_values + num_y_values),
-	      left_(ClosestValue), right_(ClosestValue)
-	{
-            assert(xmax > xmin);
-            assert(y_values_.size() > 1);
-            xdelta_ = (xmax - xmin)/(y_values_.size() - 1);
-	}
-
-	template<typename T>
-	inline std::pair<double, double>
-	UniformTableLinear<T>
-	::domain()
-	{
-	    return std::make_pair(xmin_, xmax_);
-	}
-
-	template<typename T>
-	inline void
-	UniformTableLinear<T>
-	::rescaleDomain(std::pair<double, double> new_domain)
-	{
-            xmin_ = new_domain.first;
-            xmax_ = new_domain.second;
-            xdelta_ = (xmax_ - xmin_)/(y_values_.size() - 1);
-	}
-
-	template<typename T>
-	inline double
-	UniformTableLinear<T>
-	::operator()(const double xparam) const
-	{
-            // Implements ClosestValue policy.
-            double x = std::min(xparam, xmax_);
-            x = std::max(x, xmin_);
-
-            // Lookup is easy since we are uniform in x.
-            double pos = (x - xmin_)/xdelta_;
-            double posi = std::floor(pos);
-            int left = int(posi);
-            if (left == int(y_values_.size()) - 1) {
-                // We are at xmax_
-                return y_values_.back();
-            }
-            double w = pos - posi;
-	    return (1.0 - w)*y_values_[left] + w*y_values_[left + 1];
-	}
-
-	template<typename T>
-	inline double
-	UniformTableLinear<T>
-	::derivative(const double xparam) const
-	{
-            // Implements derivative consistent
-            // with ClosestValue policy for function
-            double value;
-            if (xparam > xmax_ || xparam < xmin_) {
-                value = 0.0;
-            } else {
-                double x = std::min(xparam, xmax_);
-                x =  std::max(x, xmin_);
-                // Lookup is easy since we are uniform in x.
-                double pos = (x - xmin_)/xdelta_;
-                double posi = std::floor(pos);
-                int left = int(posi);
-                if (left == int(y_values_.size()) - 1) {
-                    // We are at xmax_
-                    --left;
-                }
-                value = (y_values_[left + 1] - y_values_[left])/xdelta_;
-            }
-            return value;
-	}
-
-
-	template<typename T>
-	inline bool
-	UniformTableLinear<T>
-	::operator==(const UniformTableLinear<T>& other) const
-	{
-	    return xmin_ == other.xmin_
-                && xdelta_ == other.xdelta_
-		&& y_values_ == other.y_values_
-		&& left_ == other.left_
-		&& right_ == other.right_;
-	}
-
-	template<typename T>
-	inline void
-	UniformTableLinear<T>
-	::setLeftPolicy(RangePolicy rp)
-	{
-	    if (rp != ClosestValue) {
-		OPM_THROW(std::runtime_error, "Only ClosestValue RangePolicy implemented.");
-	    }
-	    left_ = rp;
-	}
-
-	template<typename T>
-	inline void
-	UniformTableLinear<T>
-	::setRightPolicy(RangePolicy rp)
-	{
-	    if (rp != ClosestValue) {
-		OPM_THROW(std::runtime_error, "Only ClosestValue RangePolicy implemented.");
-	    }
-	    right_ = rp;
-	}
-
-
-        template <typename T>
-        inline std::ostream& operator<<(std::ostream& os, const UniformTableLinear<T>& t)
-        {
-            int n = t.y_values_.size();
-            for (int i = 0; i < n; ++i) {
-                double f = double(i)/double(n - 1);
-                os << (1.0 - f)*t.xmin_ + f*t.xmax_
-                   << "   " << t.y_values_[i] << '\n';
-            }
-            return os;
-        }
-
-    namespace utils
-    {
-        using Opm::UniformTableLinear;
-    }
-
-
-} // namespace Opm
-
-#endif // OPM_UNIFORMTABLELINEAR_HEADER_INCLUDED

opm/common/utility/numeric/blas_lapack.h

@@ -1,148 +0,0 @@
-/*
-  Copyright 2010 SINTEF ICT, Applied Mathematics.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_BLAS_LAPACK_HEADER_INCLUDED
-#define OPM_BLAS_LAPACK_HEADER_INCLUDED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(MATLAB_MEX_FILE) && MATLAB_MEX_FILE
-#include <mex.h>
-#undef  MAT_SIZE_T
-#define MAT_SIZE_T mwSignedIndex
-#endif
-
-#ifndef MAT_SIZE_T
-#define MAT_SIZE_T int
-#endif
-
-
-/* C <- a1*op(A)*op(B) + a2*C  where  op(X) in {X, X.'} */
-void dgemm_(const char *transA  , const char *transB   ,
-            const MAT_SIZE_T*  m, const MAT_SIZE_T* n  , const MAT_SIZE_T* k  ,
-            const double*     a1, const double*     A  , const MAT_SIZE_T* ldA,
-            const double*      B, const MAT_SIZE_T* ldB,
-            const double*     a2,       double*     C  , const MAT_SIZE_T* ldC);
-
-
-/* C <- a1*A*A' + a2*C   *or*   C <- a1*A'*A + a2*C */
-void dsyrk_(const char       *uplo, const char       *trans,
-            const MAT_SIZE_T *n   , const MAT_SIZE_T *k    ,
-            const double     *a1  , const double     *A    , const MAT_SIZE_T *ldA,
-            const double     *a2  ,       double     *C    , const MAT_SIZE_T *ldC);
-
-
-void dgeqrf_(const MAT_SIZE_T *m    , const MAT_SIZE_T *n   ,
-                   double     *A    , const MAT_SIZE_T *ld  ,
-                   double     *tau  ,       double     *work,
-             const MAT_SIZE_T *lwork,       MAT_SIZE_T *info);
-
-
-void dorgqr_(const MAT_SIZE_T *m   , const MAT_SIZE_T *n    , const MAT_SIZE_T *k  ,
-                   double     *A   , const MAT_SIZE_T *ld   , const double     *tau,
-                   double     *work, const MAT_SIZE_T *lwork,       MAT_SIZE_T *info);
-
-/* A <- LU(A) */
-void dgetrf_(const MAT_SIZE_T *m   , const MAT_SIZE_T *n ,
-             double           *A   , const MAT_SIZE_T *ld,
-             MAT_SIZE_T       *ipiv, MAT_SIZE_T       *info);
-
-/* B <- A \ B, when A is LU(A) from dgetrf() */
-void dgetrs_(const char       *trans, const MAT_SIZE_T *n,
-             const MAT_SIZE_T *nrhs ,
-             const double     *A    , const MAT_SIZE_T *lda,
-             const MAT_SIZE_T *ipiv , double           *B,
-             const MAT_SIZE_T *ldb  , MAT_SIZE_T       *info);
-
-/* B <- A \ B, tridiagonal A with bands DL, D, DU */
-void dgtsv_(const MAT_SIZE_T *n    ,
-            const MAT_SIZE_T *nrhs ,
-                  double     *DL   ,
-                  double     *D    ,
-                  double     *DU   ,
-                  double     *B    ,
-            const MAT_SIZE_T *ldb  ,
-            MAT_SIZE_T       *info);
-
-/* B <- A \ B, band matrix A stored in AB with kl subdiagonals, ku superdiagonals */
-void dgbsv_(const MAT_SIZE_T *n    ,
-            const MAT_SIZE_T *kl   ,
-            const MAT_SIZE_T *ku   ,
-            const MAT_SIZE_T *nrhs ,
-            double     *AB   ,
-            const MAT_SIZE_T *ldab ,
-            MAT_SIZE_T *ipiv ,
-            double     *B    ,
-            const MAT_SIZE_T *ldb  ,
-            MAT_SIZE_T       *info);
-
-/* B <- A \ B, general solver */
-void dgesv_(const MAT_SIZE_T *n,
-            const MAT_SIZE_T *nrhs ,
-            double     *A   ,
-            const MAT_SIZE_T *lda ,
-            MAT_SIZE_T *piv ,
-            double     *B    ,
-            const MAT_SIZE_T *ldb  ,
-            MAT_SIZE_T *info);
-
-/* A <- chol(A) */
-void dpotrf_(const char *uplo, const MAT_SIZE_T *n,
-             double     *A   , const MAT_SIZE_T *lda,
-             MAT_SIZE_T *info);
-
-/* B <- (A \ (A' \ B)), when A=DPOTRF(A_orig) */
-void dpotrs_(const char *uplo, const MAT_SIZE_T *n  , const MAT_SIZE_T *nrhs,
-             double     *A   , const MAT_SIZE_T *lda,
-             double     *B   , const MAT_SIZE_T *ldb,       MAT_SIZE_T *info);
-
-/* A <- chol(A), packed format. */
-void dpptrf_(const char *uplo, const MAT_SIZE_T *n,
-             double     *Ap  ,       MAT_SIZE_T *info);
-
-/* A <- (A \ (A' \ eye(n)) when A=DPPTRF(A_orig) (packed format). */
-void dpptri_(const char *uplo, const MAT_SIZE_T *n,
-             double     *Ap  ,       MAT_SIZE_T *info);
-
-/* y <- a1*op(A)*x + a2*y */
-void dgemv_(const char       *trans,
-            const MAT_SIZE_T *m    , const MAT_SIZE_T *n,
-            const double     *a1   , const double     *A, const MAT_SIZE_T *ldA ,
-                                     const double     *x, const MAT_SIZE_T *incX,
-            const double     *a2   ,       double     *y, const MAT_SIZE_T *incY);
-
-
-/* y <- a*x + y */
-void daxpy_(const MAT_SIZE_T *n, const double *a,
-            const double *x, const MAT_SIZE_T *incx,
-                  double *y, const MAT_SIZE_T *incy);
-
-/* s <- x' * y */
-double ddot_(const MAT_SIZE_T *n, const double *x, const MAT_SIZE_T *incx,
-                                  const double *y, const MAT_SIZE_T *incy);
-
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* OPM_BLAS_LAPACK_HEADER_INCLUDED */

opm/common/utility/numeric/buildUniformMonotoneTable.hpp

@@ -1,50 +0,0 @@
-/*
-  Copyright 2010 SINTEF ICT, Applied Mathematics.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_BUILDUNIFORMMONOTONETABLE_HEADER_INCLUDED
-#define OPM_BUILDUNIFORMMONOTONETABLE_HEADER_INCLUDED
-
-#include <opm/core/utility/MonotCubicInterpolator.hpp>
-#include <opm/core/utility/UniformTableLinear.hpp>
-
-namespace Opm {
-
-    template <typename T>
-    void buildUniformMonotoneTable(const std::vector<double>& xv,
-                                   const std::vector<T>& yv,
-                                   const int samples,
-                                   UniformTableLinear<T>& table)
-    {
-        MonotCubicInterpolator interp(xv, yv);
-        std::vector<T> uniform_yv(samples);
-        double xmin = xv[0];
-        double xmax = xv.back();
-        for (int i = 0; i < samples; ++i) {
-            double w = double(i)/double(samples - 1);
-            double x = (1.0 - w)*xmin + w*xmax;
-            uniform_yv[i] = interp(x);
-        }
-        table = UniformTableLinear<T>(xmin, xmax, uniform_yv);
-    }
-
-} // namespace Opm
-
-
-
-#endif // OPM_BUILDUNIFORMMONOTONETABLE_HEADER_INCLUDED

opm/common/utility/numeric/calculateCellVol.hpp

@@ -1,24 +0,0 @@
-/*
-  Copyright 2018 Statoil ASA.
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <vector>
-#include <math.h>  
-
-
-double calculateCellVol(const std::vector<double>& X, const std::vector<double>& Y, const std::vector<double>& Z);
-
-

opm/common/utility/numeric/linearInterpolation.hpp

@@ -1,107 +0,0 @@
-/*
-  Copyright 2009, 2010, 2013 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_LINEARINTERPOLATION_HEADER_INCLUDED
-#define OPM_LINEARINTERPOLATION_HEADER_INCLUDED
-
-
-#include <vector>
-#include <algorithm>
-
-namespace Opm
-{
-
-    inline int tableIndex(const std::vector<double>& table, double x)
-    {
-	// Returns an index in an ordered table such that x is between
-	// table[j] and table[j+1]. If x is out of range, first or last
-	// interval is returned; Binary search.
-	int n = table.size() - 1;
-	if (n < 2) {
-	    return 0;
-	}
-	int jl = 0;
-	int ju = n;
-	bool ascend = (table[n] > table[0]);
-	while (ju - jl > 1) {
-	    int jm = (ju + jl)/2;   // Compute a midpoint
-	    if ( (x >= table[jm]) == ascend) {
-		jl = jm;     // Replace lower limit
-	    } else {
-		ju = jm;     // Replace upper limit
-	    }
-	}
-	return jl;
-    }
-
-
-    inline double linearInterpolationDerivative(const std::vector<double>& xv,
-                                                const std::vector<double>& yv, double x)
-    {
-        // Extrapolates if x is outside xv
-	int ix1 = tableIndex(xv, x);
-	int ix2 = ix1 + 1;
-	return  (yv[ix2] - yv[ix1])/(xv[ix2] - xv[ix1]);
-    }
-
-    inline double linearInterpolation(const std::vector<double>& xv,
-                                      const std::vector<double>& yv, double x)
-    {
-	// Extrapolates if x is outside xv
-	int ix1 = tableIndex(xv, x);
-	int ix2 = ix1 + 1;
-	return  (yv[ix2] - yv[ix1])/(xv[ix2] - xv[ix1])*(x - xv[ix1]) + yv[ix1];
-    }
-
-    inline double linearInterpolationNoExtrapolation(const std::vector<double>& xv,
-                                                     const std::vector<double>& yv, double x)
-    {
-        // Return end values if x is outside xv
-        if (x < xv.front()) {
-            return yv.front();
-        }
-        if (x > xv.back()) {
-            return yv.back();
-        }
-
-        int ix1 = tableIndex(xv, x);
-        int ix2 = ix1 + 1;
-        return  (yv[ix2] - yv[ix1])/(xv[ix2] - xv[ix1])*(x - xv[ix1]) + yv[ix1];
-    }
-
-    inline double linearInterpolation(const std::vector<double>& xv,
-                                      const std::vector<double>& yv,
-                                      double x, int& ix1)
-    {
-	// Extrapolates if x is outside xv
-	ix1 = tableIndex(xv, x);
-	int ix2 = ix1 + 1;
-	return (yv[ix2] - yv[ix1])/(xv[ix2] - xv[ix1])*(x - xv[ix1]) + yv[ix1];
-    }
-
-
-
-} // namespace Opm
-
-
-
-
-
-#endif // OPM_LINEARINTERPOLATION_HEADER_INCLUDED

opm/common/utility/parameters/Parameter.hpp

@@ -1,215 +0,0 @@
-//===========================================================================
-//
-// File: Parameter.hpp
-//
-// Created: Tue Jun  2 16:00:21 2009
-//
-// Author(s): B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//            Atgeirr F Rasmussen <atgeirr@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_PARAMETER_HEADER
-#define OPM_PARAMETER_HEADER
-
-#include <string>
-#include <sstream>
-
-#include <opm/common/utility/parameters/ParameterMapItem.hpp>
-#include <opm/common/utility/parameters/ParameterStrings.hpp>
-
-namespace Opm {
-	/// @brief
-	/// @todo Doc me!
-	class Parameter : public ParameterMapItem {
-	public:
-	    /// @brief
-	    /// @todo Doc me!
-	    virtual ~Parameter() {}
-	    /// @brief
-	    /// @todo Doc me!
-	    /// @return
-	    virtual std::string getTag() const {return ID_xmltag__param;}
-	    /// @brief
-	    /// @todo Doc me!
-	    /// @param
-	    Parameter(const std::string& value, const std::string& type)
-                : value_(value), type_(type) {}
-	    /// @brief
-	    /// @todo Doc me!
-	    /// @return
-	    std::string getValue() const {return value_;}
-	    /// @brief
-	    /// @todo Doc me!
-	    /// @return
-	    std::string getType() const {return type_;}
-	private:
-	    std::string value_;
-	    std::string type_;
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @param
-	/// @return
-	std::string correct_parameter_tag(const ParameterMapItem& item);
-	std::string correct_type(const Parameter& parameter,
-                                 const std::string& type);
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	template<>
-	struct ParameterMapItemTrait<int> {
-	    static int convert(const ParameterMapItem& item,
-                               std::string& conversion_error,
-                               const bool)
-            {
-		conversion_error = correct_parameter_tag(item);
-		if (conversion_error != "") {
-		    return 0;
-		}
-		const Parameter& parameter = dynamic_cast<const Parameter&>(item);
-		conversion_error = correct_type(parameter, ID_param_type__int);
-		if (conversion_error != "") {
-		    return 0;
-		}
-		std::stringstream stream;
-		stream << parameter.getValue();
-		int value;
-		stream >> value;
-		if (stream.fail()) {
-		    conversion_error = "Conversion to '" +
-                                       ID_param_type__int +
-                                       "' failed. Data was '" +
-                                       parameter.getValue() + "'.\n";
-		    return 0;
-		}
-		return value;
-	    }
-	    static std::string type() {return ID_param_type__int;}
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	template<>
-	struct ParameterMapItemTrait<double> {
-	    static double convert(const ParameterMapItem& item,
-                                  std::string& conversion_error,
-                                  const bool)
-            {
-		conversion_error = correct_parameter_tag(item);
-		if (conversion_error != "") {
-		    return 0.0;
-		}
-		const Parameter& parameter = dynamic_cast<const Parameter&>(item);
-		conversion_error = correct_type(parameter, ID_param_type__float);
-		if (conversion_error != "") {
-		    return 0.0;
-		}
-		std::stringstream stream;
-		stream << parameter.getValue();
-		double value;
-		stream >> value;
-		if (stream.fail()) {
-		    conversion_error = "Conversion to '" +
-                                       ID_param_type__float +
-                                       "' failed. Data was '" +
-                                       parameter.getValue() + "'.\n";
-		    return 0.0;
-		}
-		return value;
-	    }
-	    static std::string type() {return ID_param_type__float;}
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	template<>
-	struct ParameterMapItemTrait<bool> {
-	    static bool convert(const ParameterMapItem& item,
-                                std::string& conversion_error,
-                                const bool)
-            {
-		conversion_error = correct_parameter_tag(item);
-		if (conversion_error != "") {
-		    return false;
-		}
-		const Parameter& parameter = dynamic_cast<const Parameter&>(item);
-		conversion_error = correct_type(parameter, ID_param_type__bool);
-		if (conversion_error != "") {
-		    return false;
-		}
-		if (parameter.getValue() == ID_true) {
-		    return true;
-		} else if (parameter.getValue() == ID_false) {
-		    return false;
-		} else {
-		    conversion_error = "Conversion failed. Data was '" +
-                                       parameter.getValue() +
-                                       "', but should be one of '" +
-                                       ID_true + "' or '" + ID_false + "'.\n";
-		    return false;
-		}
-	    }
-	    static std::string type() {return ID_param_type__bool;}
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	template<>
-	struct ParameterMapItemTrait<std::string> {
-	    static std::string convert(const ParameterMapItem& item,
-                                       std::string& conversion_error,
-                                       const bool)
-            {
-		conversion_error = correct_parameter_tag(item);
-		if (conversion_error != "") {
-		    return "";
-		}
-		const Parameter& parameter = dynamic_cast<const Parameter&>(item);
-		conversion_error = correct_type(parameter, ID_param_type__string);
-		if (conversion_error != "") {
-		    return "";
-		}
-		return parameter.getValue();
-	    }
-	    static std::string type() {return ID_param_type__string;}
-	};
-} // namespace Opm
-#endif  // OPM_PARAMETER_HPP

opm/common/utility/parameters/ParameterGroup.hpp

@@ -1,272 +0,0 @@
-//===========================================================================
-//
-// File: ParameterGroup.hpp
-//
-// Created: Tue Jun  2 19:11:11 2009
-//
-// Author(s): B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//            Atgeirr F Rasmussen <atgeirr@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_PARAMETERGROUP_HEADER
-#define OPM_PARAMETERGROUP_HEADER
-
-#include <exception>
-#include <map>
-#include <string>
-#include <vector>
-#include <memory>
-#include <opm/common/utility/parameters/ParameterMapItem.hpp>
-#include <opm/common/utility/parameters/ParameterRequirement.hpp>
-
-namespace Opm {
-	/// ParameterGroup is a class that is used to provide run-time parameters.
-	/// The standard use of the class is to call create it with the
-	/// (int argc, char** argv) constructor (where the arguments are those
-	/// given by main). This parses the command line, where each token
-	/// either
-	/// A) specifies a parameter (by a "param=value" token).
-	/// B) specifies a param file to be read (by a "filename.param" token).
-	/// After the tokens are parsed they are stored in a tree structure
-	/// in the ParameterGroup object; it is worth mentioning that parameters
-	/// are inherited in this tree structure. Thus, if ``grid\_prefix'' is
-	/// given a value in the root node, this value will be visible in all
-	/// parts of the tree (unless the parameter is overwritten in a subtree).
-	/// Applications using this ParameterGroup objects will usually write out
-	/// a message for each node in the three that is used by the application;
-	/// this is one way to determine valid parameters.
-	///
-	/// Parameters specified as "param=value" on the command line
-	///
-	/// To specify a parameter on the command line, you must know where in the tree the
-	/// parameter resides. The syntax for specifying parameters on the command line given
-	/// an application called ``simulator'' is
-	///         simulator param1=value grp/param2=value
-	//  for parameter ``param1'' lying at the root and ``param2'' in the group
-	/// ``grp''. If the same parameters are specified multiple times on the command
-	/// line, only the last will be used. Thus an application named ``simulator'' run with
-	/// the following command
-	///         simulator param=value1 param=value2
-	/// will use value2 as the value of ``param''.
-	///
-	/// param files
-	///
-	/// A param file consists of multiple lienes, where each line consists of "param=value".
-	/// This syntax is identical to the one for parameters specified on the command line.
-	class ParameterGroup : public ParameterMapItem {
-	public:
-	    struct NotFoundException          : public std::exception {};
-	    struct WrongTypeException         : public std::exception {};
-	    struct ConversionFailedException  : public std::exception {};
-
-	    template<typename T>
-	    struct RequirementFailedException : public std::exception {};
-
-	    ParameterGroup();
-	    ParameterGroup(const std::string& path, const ParameterGroup* parent,
-                           const bool enable_output);
-
-	    // From ParameterMapItem
-	    virtual ~ParameterGroup();
-	    virtual std::string getTag() const;
-
-	    /// \brief A constructor typically used to initialize a
-	    ///        ParameterGroup from command-line arguments.
-	    ///
-	    /// It is required that argv[0] is the program name, while if
-	    /// 0 < i < argc, then argv[i] is either
-	    /// the name of a parameter file or parametername=value.
-	    ///
-	    /// \param argc is the number of command-line arguments,
-	    ///        including the name of the executable.
-	    /// \param argv is an array of char*, each of which is a
-	    ///        command line argument.
-	    /// \param verify_syntax  If true (default), then it is an error to
-	    ///        pass arguments that cannot be handled by the ParameterGroup,
-	    ///        or an empty argument list. If false, such arguments are stored
-	    ///        and can be retrieved later with unhandledArguments().
-            /// \param enable_output Whether to enable output or not.
-            template <typename StringArray>
-	    ParameterGroup(int argc, StringArray argv, const bool verify_syntax = true,
-                           const bool enabled_output=true);
-
-	    /// \brief This method checks if there is something with name
-	    ///        \p name in the parameter gropup.
-	    ///
-	    /// \param name is the name of the parameter.
-	    /// \return true if \p name is the name of something in the parameter
-	    ///         group, false otherwise.
-	    bool has(const std::string& name) const;
-
-	    /// \brief This method is used to read a parameter from the
-	    ///        parameter group.
-	    ///
-	    /// NOTE:  If the reading of the parameter fails, then this method
-	    ///        throws an appropriate exception.
-	    ///
-	    /// \param name is the name of the parameter in question.
-	    /// \return The value associated with then name in this parameter
-	    ///         group.
-	    template<typename T>
-	    T get(const std::string& name) const;
-
-	    template<typename T, class Requirement>
-	    T get(const std::string& name, const Requirement&) const;
-
-	    /// \brief This method is used to read a parameter from the
-	    ///        parameter group.
-	    ///
-	    /// NOTE:  If the reading of the parameter fails, then either
-	    ///        a) this method returns \p default_value if there
-	    ///           was no parameter with name \p name in
-	    ///           the parameter group
-	    ///        or
-	    ///        b) this method throws an appropriate exception.
-	    ///
-	    /// \param name is the name of the parameter in question.
-	    /// \param default_value the default value of the parameter in
-	    ///        question.
-	    /// \return The value associated with this name in this parameter
-	    ///         group.
-	    template<typename T>
-	    T getDefault(const std::string& name,
-			 const T& default_value) const;
-
-	    template<typename T, class Requirement>
-	    T getDefault(const std::string& name,
-			 const T& default_value,
-			 const Requirement& r) const;
-
-	    /// \brief This method returns the parameter group given by name,
-	    ///        i.e. it is an alias of get<ParameterGroup>().
-	    ///
-	    /// \param name is the name of the parameter group sought.
-	    /// \return the parameter group sought.
-	    ParameterGroup getGroup(const std::string& name) const;
-
-	    /// \brief Disables the output from get, getDefault and getGroup.
-	    ///        By default, such output is enabled.
-	    void disableOutput();
-
-	    /// \brief Enables the output from get, getDefault and getGroup.
-	    ///        By default, such output is enabled.
-	    void enableOutput();
-
-	    /// \brief Returs true if and only if output from get, getDefault
-	    ///        and getGroup is enabled.
-	    ///
-	    /// \return true if and only if output from get, getDefault and
-	    ///         getGroup is enabled.
-	    bool isOutputEnabled() const;
-
-	    /// \brief Reads the contents of the param file specified by
-	    ///        param_filename into this ParameterGroup.
-	    ///
-	    /// NOTE: A param file contains lines on the form 'a/b/c=d'.
-	    //        The '/' separates ParameterGroups and Parameters
-	    ///       (e.g. c is a Parameter in the ParameterGroup b,
-	    ///       and b is a ParameterGroup in the ParameterGroup a)
-	    ///       while '=' separates the name from the value (e.g. the
-	    ///       value of the parameter c above will be d).
-	    /// NOTE: A param file does not store any type information about
-	    ///       its values.
-	    ///
-	    /// \param param_filename is the name of a param file.
-	    void readParam(const std::string& param_filename);
-
-	    /// \brief Writes this ParameterGroup into a param file
-	    ///        specified by param_filename.
-	    ///
-	    /// \param param_filename is the name of a param file.
-	    void writeParam(const std::string& param_filename) const;
-
-	    /// \brief Writes this ParameterGroup to a stream.
-	    ///
-	    /// \param stream is the stream to write to.
-	    void writeParamToStream(std::ostream& stream) const;
-
-
-	    /// vki param interface - deprecated
-	    template<typename T>
-	    void get(const char* name, T& value, const T& default_value) const {
-		value = this->getDefault<T>(name, default_value);
-	    }
-
-	    /// vki param interface - deprecated
-	    template<typename T>
-	    void get(const char* name, T& value) const {
-		value = this->get<T>(name);
-	    }
-
-            /// \brief Return true if any parameters are unused.
-            bool anyUnused() const;
-
-	    /// \brief Shows which parameters which are used or unused.
-	    void displayUsage(bool used_params = false) const;
-
-            /// \brief Returns the path of the parameter group.
-	    std::string path() const;
-
-            /// Insert a new item into the group.
-	    void insert(const std::string& name,
-                        const std::shared_ptr<ParameterMapItem>& data);
-
-            /// Insert a new parameter item into the group.
-	    void insertParameter(const std::string& name, const std::string& value);
-
-            /// Unhandled arguments from command line parsing.
-            const std::vector<std::string>& unhandledArguments() const;
-
-	private:
-	    typedef std::shared_ptr<ParameterMapItem> data_type;
-	    typedef std::pair<std::string, data_type> pair_type;
-	    typedef std::map<std::string, data_type> map_type;
-
-	    std::string path_;
-	    map_type map_;
-	    const ParameterGroup* parent_;
-	    bool output_is_enabled_;
-	    std::vector<std::string> unhandled_arguments_;
-
-	    template<typename T, class Requirement>
-	    T translate(const pair_type& data, const Requirement& chk) const;
-            template <typename StringArray>
-	    void parseCommandLineArguments(int argc, StringArray argv, bool verify_syntax);
-	    void recursiveSetIsOutputEnabled(bool output_is_enabled);
-
-	    // helper routines to do textual I/O
-	    template <typename T>
-	    static std::string to_string(const T& val);
-	    static std::pair<std::string, std::string>
-	    filename_split(const std::string& filename);
-	};
-} // namespace Opm
-
-#include <opm/common/utility/parameters/ParameterGroup_impl.hpp>
-
-#endif // OPM_PARAMETERGROUP_HEADER

opm/common/utility/parameters/ParameterGroup_impl.hpp

@@ -1,311 +0,0 @@
-//===========================================================================
-//
-// File: ParameterGroup_impl.hpp
-//
-// Created: Tue Jun  2 19:06:46 2009
-//
-// Author(s): B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//            Atgeirr F Rasmussen <atgeirr@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_PARAMETERGROUP_IMPL_HEADER
-#define OPM_PARAMETERGROUP_IMPL_HEADER
-
-#include <iostream>
-#include <string>
-#include <stdexcept>
-
-#include <opm/common/utility/parameters/ParameterGroup.hpp>
-#include <opm/common/utility/parameters/ParameterStrings.hpp>
-#include <opm/common/utility/parameters/ParameterTools.hpp>
-#include <opm/common/utility/parameters/Parameter.hpp>
-#include <opm/common/ErrorMacros.hpp>
-#include <opm/common/OpmLog/OpmLog.hpp>
-
-namespace Opm {
-	template<>
-	struct ParameterMapItemTrait<ParameterGroup> {
-	    static ParameterGroup
-            convert(const ParameterMapItem& item,
-                    std::string& conversion_error,
-                    bool enable_output)
-            {
-		std::string tag = item.getTag();
-		if (tag != ID_xmltag__param_grp) {
-		    conversion_error = "The XML tag was '" + tag +
-                                       "' but should be '" +
-                                       ID_xmltag__param_grp + "'.\n";
-		    return ParameterGroup("", 0, enable_output);
-		}
-		conversion_error = "";
-		const ParameterGroup& pg = dynamic_cast<const ParameterGroup&>(item);
-		return pg;
-	    }
-	    static std::string type() {return "ParameterGroup";}
-	};
-
-	    template <typename T>
-	    inline std::string
-	    ParameterGroup::to_string(const T& val)
-	    {
-		std::ostringstream os;
-		os << val;
-		return os.str();
-	    }
-
-	    template <>
-	    inline std::string
-	    ParameterGroup::to_string(const bool& b) {
-		if (b) {
-		    return ID_true;
-		} else {
-		    return ID_false;
-		}
-	    }
-
-	    template <>
-	    inline std::string
-	    ParameterGroup::to_string(const ParameterGroup&)
-	    {
-		return std::string("<parameter group>");
-	    }
-
-	    inline std::pair<std::string, std::string>
-	    ParameterGroup::filename_split(const std::string& filename)
-            {
-		int fpos = filename.rfind('.');
-		std::string name = filename.substr(0, fpos);
-		std::string type = filename.substr(fpos+1);
-		return std::make_pair(name, type);
-	    }
-
-        template <typename StringArray>
-	ParameterGroup::ParameterGroup(int argc, StringArray argv, bool verify_syntax,
-                                       const bool enable_output)
-            : path_(ID_path_root), parent_(0), output_is_enabled_(enable_output)
-	{
-	    if (verify_syntax && (argc < 2)) {
-		std::cerr << "Usage: " << argv[0] << " "
-			  << "[paramfilename1.param] "
-			  << "[paramfilename2.param] "
-			  << "[overridden_arg1=value1] "
-			  << "[overridden_arg2=value2] "
-			  << "[...]" << std::endl;
-		exit(EXIT_FAILURE);
-	    }
-	    this->parseCommandLineArguments(argc, argv, verify_syntax);
-	}
-
-        template <typename StringArray>
-	void ParameterGroup::parseCommandLineArguments(int argc, StringArray argv, bool verify_syntax)
-        {
-	    std::vector<std::string> files;
-	    std::vector<std::pair<std::string, std::string> > assignments;
-	    for (int i = 1; i < argc; ++i) {
-		std::string arg(argv[i]);
-		int fpos = arg.find(ID_delimiter_assignment);
-		if (fpos == int(std::string::npos)) {
-		    std::string filename = arg.substr(0, fpos);
-		    files.push_back(filename);
-		    continue;
-		}
-		int pos = fpos + ID_delimiter_assignment.size();
-		int spos = arg.find(ID_delimiter_assignment, pos);
-		if (spos == int(std::string::npos)) {
-		    std::string name = arg.substr(0, fpos);
-		    std::string value = arg.substr(pos, spos);
-		    assignments.push_back(std::make_pair(name, value));
-		    continue;
-		}
-        	OpmLog::warning("Too many assignements  (' "
-                	        + ID_delimiter_assignment
-	                        + "') detected in argument " + to_string(i));
-	    }
-	    for (int i = 0; i < int(files.size()); ++i) {
-		std::pair<std::string, std::string> file_type = filename_split(files[i]);
-		if (file_type.second == "param") {
-		    this->readParam(files[i]);
-		} else {
-                    if (verify_syntax) {
-                        std::cerr << "ERROR: Input '" << files[i] << "' is not a valid name for a parameter file.\n";
-                        std::cerr << "       Valid filename extensions are 'param'.\n";
-                        OPM_THROW(std::runtime_error, "ParameterGroup cannot handle argument: " << files[i]);
-                    } else {
-                        unhandled_arguments_.push_back(files[i]);
-                    }
-		}
-	    }
-	    for (int i = 0; i < int(assignments.size()); ++i) {
-		this->insertParameter(assignments[i].first, assignments[i].second);
-	    }
-	}
-
-
-	template<typename T>
-	inline T ParameterGroup::get(const std::string& name) const
-        {
-	    return this->get<T>(name, ParameterRequirementNone());
-	}
-
-	template<typename T, class Requirement>
-	inline T ParameterGroup::get(const std::string& name,
-				     const Requirement& r) const
-        {
-	    setUsed();
-	    std::pair<std::string, std::string> name_path = splitParam(name);
-	    map_type::const_iterator it = map_.find(name_path.first);
-	    if (it == map_.end()) {
-		if (parent_ != 0) {
-		    // If we have a parent, ask it instead.
-		    if (output_is_enabled_) {
-                	OpmLog::warning(name + "not found at " + path() + ID_delimiter_path + ", asking parent.");
-		    }
-		    return parent_->get<T>(name, r);
-		} else {
-		    // We are at the top, name has not been found.
-		    std::cerr << "ERROR: The group '"
-			      << this->path()
-			      << "' does not contain an element named '"
-			      << name
-			      << "'.\n";
-		    throw NotFoundException();
-		}
-	    }
-	    if (name_path.second == "") {
-		T val = this->translate<T>(*it, r);
-		it->second->setUsed();
-		if (output_is_enabled_) {
-		    OpmLog::debug(name + " found at " + path() + ID_delimiter_path + ", value is " + to_string(val));
-		}
-		return val;
-	    } else {
-		ParameterGroup& pg = dynamic_cast<ParameterGroup&>(*(*it).second);
-		pg.setUsed();
-		return pg.get<T>(name_path.second, r);
-	    }
-	}
-
-	template<typename T>
-	inline T ParameterGroup::getDefault(const std::string& name,
-					    const T& default_value) const
-        {
-	    return this->getDefault<T>(name, default_value, ParameterRequirementNone());
-	}
-
-	template<typename T, class Requirement>
-	inline T ParameterGroup::getDefault(const std::string& name,
-					    const T& default_value,
-					    const Requirement& r) const
-        {
-	    setUsed();
-	    std::pair<std::string, std::string> name_path = splitParam(name);
-	    map_type::const_iterator it = map_.find(name_path.first);
-	    if (it == map_.end()) {
-		if (parent_ != 0) {
-		    // If we have a parent, ask it instead.
-		    if (output_is_enabled_) {
-                	OpmLog::warning(name + " not found at " + path() + ID_delimiter_path + ", asking parent.");
-		    }
-		    return parent_->getDefault<T>(name, default_value, r);
-		} else {
-		    // We check the requirement for the default value
-		    std::string requirement_result = r(default_value);
-		    if (requirement_result != "") {
-			std::cerr << "ERROR: The default value for the "
-				  << " element named '"
-				  << name
-				  << "' in the group '"
-				  << this->path()
-				  << "' failed to meet a requirenemt.\n";
-			std::cerr << "The requirement enforcer returned the following message:\n"
-				  << requirement_result
-				  << "\n";
-			throw RequirementFailedException<Requirement>();
-		    }
-		}
-		if (output_is_enabled_) {
-            	    OpmLog::debug(name + " not found. Using default value '" + to_string(default_value) + "'.");
-		}
-		return default_value;
-	    }
-	    if (name_path.second == "") {
-		T val = this->translate<T>(*it, r);
-		it->second->setUsed();
-		if (output_is_enabled_) {
-            	    OpmLog::debug(name + " found at " + path() + ID_delimiter_path 
-                         + ", value is '" + to_string(val) + "'.");
-		}
-		return val;
-	    } else {
-		ParameterGroup& pg = dynamic_cast<ParameterGroup&>(*(*it).second);
-		pg.setUsed();
-		return pg.getDefault<T>(name_path.second, default_value, r);
-	    }
-	}
-
-	template<typename T, class Requirement>
-	inline T ParameterGroup::translate(const pair_type& named_data,
-					   const Requirement& chk) const
-        {
-	    const std::string& name = named_data.first;
-	    const data_type data = named_data.second;
-	    std::string conversion_error;
-	    T value = ParameterMapItemTrait<T>::convert(*data, conversion_error,
-                                                        output_is_enabled_);
-	    if (conversion_error != "") {
-		std::cerr << "ERROR: Failed to convert the element named '"
-			  << name
-			  << "' in the group '"
-			  << this->path()
-			  << "' to the type '"
-			  << ParameterMapItemTrait<T>::type()
-			  << "'.\n";
-		std::cerr << "The conversion routine returned the following message:\n"
-			  << conversion_error
-			  << "\n";
-		throw WrongTypeException();
-	    }
-	    std::string requirement_result = chk(value);
-	    if (requirement_result != "") {
-		std::cerr << "ERROR: The element named '"
-			  << name
-			  << "' in the group '"
-			  << this->path()
-			  << "' of type '"
-			  << ParameterMapItemTrait<T>::type()
-			  << "' failed to meet a requirenemt.\n";
-		std::cerr << "The requirement enforcer returned the following message:\n"
-			  << requirement_result
-			  << "\n";
-		throw RequirementFailedException<Requirement>();
-	    }
-	    return value;
-	}
-} // namespace Opm
-
-#endif // OPM_PARAMETERGROUP_IMPL_HEADER

opm/common/utility/parameters/ParameterMapItem.hpp

@@ -1,71 +0,0 @@
-//===========================================================================
-//
-// File: ParameterMapItem.hpp
-//
-// Created: Tue Jun  2 19:05:54 2009
-//
-// Author(s): B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//            Atgeirr F Rasmussen <atgeirr@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_PARAMETERMAPITEM_HEADER
-#define OPM_PARAMETERMAPITEM_HEADER
-
-#include <string>
-
-namespace Opm {
-	/// The parameter handlig system is structured as a tree,
-	/// where each node inhertis from ParameterMapItem.
-	///
-	/// The abstract virtual function getTag() is  used to determine
-	/// which derived class the node actually is.
-	struct ParameterMapItem {
-	    /// Default constructor
-	    ParameterMapItem() : used_(false) {}
-
-	    /// Destructor
-	    virtual ~ParameterMapItem() {}
-
-	    /// \brief This function returns a string describing
-	    ///        the ParameterMapItem.
-	    virtual std::string getTag() const = 0;
-	    void setUsed() const { used_ = true; }
-	    bool used() const { return used_; }
-	private:
-	    mutable bool used_;
-	};
-
-	template<typename T>
-	struct ParameterMapItemTrait {
-	    static T convert(const ParameterMapItem&,
-                             std::string& conversion_error);
-	    static std::string type();
-	};
-} // namespace Opm
-
-#endif // OPM_PARAMETERMAPITEM_HEADER

opm/common/utility/parameters/ParameterRequirement.hpp

@@ -1,241 +0,0 @@
-//===========================================================================
-//
-// File: ParameterRequirement.hpp
-//
-// Created: Tue Jun  2 19:05:02 2009
-//
-// Author(s): B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//            Atgeirr F Rasmussen <atgeirr@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_PARAMETERREQUIREMENT_HEADER
-#define OPM_PARAMETERREQUIREMENT_HEADER
-
-#include <algorithm>
-#include <cassert>
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace Opm {
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	struct ParameterRequirementNone {
-	    template<typename T>
-	    std::string operator()(const T&) const {
-		return "";
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @param
-	/// @return
-	struct ParameterRequirementProbability {
-	    std::string operator()(double x) const {
-		if ( (x < 0.0) || (x > 1.0) ) {
-		    std::ostringstream stream;
-		    stream << "The value '" << x
-                           << "' is not in the interval [0, 1].";
-		    return stream.str();
-		} else {
-		    return "";
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	struct ParameterRequirementPositive {
-	    template<typename T>
-	    std::string operator()(const T& x) const {
-		if (x > 0) {
-		    return "";
-		} else {
-		    std::ostringstream stream;
-		    stream << "The value '" << x << "' is not positive.";
-		    return stream.str();
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	struct ParameterRequirementNegative {
-	    template<typename T>
-	    std::string operator()(const T& x) const {
-		if (x < 0) {
-		    return "";
-		} else {
-		    std::ostringstream stream;
-		    stream << "The value '" << x << "' is not negative.";
-		    return stream.str();
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	struct ParameterRequirementNonPositive {
-	    template<typename T>
-	    std::string operator()(const T& x) const {
-		if (x > 0) {
-		    std::ostringstream stream;
-		    stream << "The value '" << x << "' is positive.";
-		    return stream.str();
-		} else {
-		    return "";
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	struct ParameterRequirementNonNegative {
-	    template<typename T>
-	    std::string operator()(const T& x) const {
-		if (x < 0) {
-		    std::ostringstream stream;
-		    stream << "The value '" << x << "' is negative.";
-		    return stream.str();
-		} else {
-		    return "";
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	struct ParameterRequirementNonZero {
-	    template<typename T>
-	    std::string operator()(const T& x) const {
-		if (x != 0) {
-		    return "";
-		} else {
-		    return "The value was zero.";
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @param
-	/// @return
-	struct ParameterRequirementNonEmpty {
-	    std::string operator()(const std::string& x) const {
-		if (x != "") {
-		    return "The string was empty.";
-		} else {
-		    return "";
-		}
-	    }
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @tparam
-	/// @param
-	/// @return
-	template<class Requirement1, class Requirement2>
-	struct ParameterRequirementAnd {
-	    ParameterRequirementAnd(const Requirement1& r1, const Requirement2& r2) :
-	    r1_(r1), r2_(r2) { }
-
-	    template<typename T>
-	    std::string operator()(const T& t) const {
-		std::string e1 = r1_(t);
-		std::string e2 = r2_(t);
-		if (e1 == "") {
-		    return e2;
-		} else if (e2 == "") {
-		    return e1;
-		} else {
-		    return e1 + " AND " + e2;
-		}
-	    }
-	private:
-	    const Requirement1 r1_;
-	    const Requirement2 r2_;
-	};
-
-	/// @brief
-	/// @todo Doc me!
-	/// @param
-	struct ParameterRequirementMemberOf {
-	    explicit ParameterRequirementMemberOf(const std::vector<std::string>& elements)
-	    : elements_(elements) {
-		assert(elements_.size() > 0);
-	    }
-
-	/// @brief
-	/// @todo Doc me!
-	/// @param
-	/// @return
-	    std::string operator()(const std::string& x) const {
-		if (std::find(elements_.begin(), elements_.end(), x) == elements_.end()) {
-		    if (elements_.size() == 1) {
-			return "The string '" + x + "' is not '" + elements_[0] + "'.";
-		    }
-		    std::ostringstream stream;
-		    stream << "The string '" << x << "' is not among '";
-		    for (int i = 0; i < int(elements_.size()) - 2; ++i) {
-			stream << elements_[i] << "', '";
-		    }
-		    stream << elements_[elements_.size() - 2]
-			   << "' and '"
-			   << elements_[elements_.size() - 1]
-			   << "'.";
-		    return stream.str();
-		} else {
-		    return "";
-		}
-	    }
-	private:
-	    const std::vector<std::string> elements_;
-	};
-} // namespace Opm
-
-#endif // OPM_PARAMETERREQUIREMENT_HEADER

opm/common/utility/parameters/ParameterStrings.hpp

@@ -1,63 +0,0 @@
-//===========================================================================
-//
-// File: ParameterStrings.hpp
-//
-// Created: Tue Jun  2 19:04:15 2009
-//
-// Author(s): B<>rd Skaflestad     <bard.skaflestad@sintef.no>
-//            Atgeirr F Rasmussen <atgeirr@sintef.no>
-//
-// $Date$
-//
-// $Revision$
-//
-//===========================================================================
-
-/*
-  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
-  Copyright 2009, 2010 Statoil ASA.
-
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef OPM_PARAMETERSTRINGS_HEADER
-#define OPM_PARAMETERSTRINGS_HEADER
-
-#include <string>
-
-namespace Opm {
-	const std::string ID_true                   = "true";
-	const std::string ID_false                  = "false";
-
-	const std::string ID_xmltag__param_grp      = "ParameterGroup";
-	const std::string ID_xmltag__param          = "Parameter";
-
-	const std::string ID_param_type__bool       = "bool";
-	const std::string ID_param_type__int        = "int";
-	const std::string ID_param_type__float      = "double";
-	const std::string ID_param_type__string     = "string";
-	const std::string ID_param_type__file       = "file";
-	const std::string ID_param_type__cmdline    = "cmdline";
-
-	//
-
-	const std::string ID_path_root            = "";
-	const std::string ID_delimiter_path       = "/";
-	const std::string ID_comment              = "//";
-	const std::string ID_delimiter_assignment = "=";
-} // namespace Opm
-
-#endif // OPM_PARAMETERSTRINGS_HEADER