Merge pull request #610 from jalvestad/restart_hyster

Add changes to correct problems/errors with Eclipse restarts from flow  with hysteresis and well crossflow

CMakeLists.txt

@@ -7,6 +7,7 @@ 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)
+option(ENABLE_MOCKSIM "Build the mock simulator for io testing" ON)
 
 # Output implies input
 if(ENABLE_ECL_OUTPUT)
@@ -18,6 +19,7 @@ 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)
@@ -36,12 +38,10 @@ set(OPM_PROJECT_EXTRA_CODE_INTREE "#ENABLE_ECL_INPUT is needed by opm-common-pre
                                    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_PACK_COMMAND ${CMAKE_INSTALL_PREFIX}/bin${${name}_VER_DIR}/opmpack)")
 
   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)
                                      set(OPM_PACK_COMMAND ${PROJECT_BINARY_DIR}/bin/opmpack)")
 endif()
@@ -132,5 +132,61 @@ endmacro (install_hook)
 # all setup common to the OPM library modules is done here
 include (OpmLibMain)
 
+if (ENABLE_MOCKSIM)
+  add_library(mocksim
+              msim/src/msim.cpp)
+  target_link_libraries(mocksim opmcommon)
+  target_include_directories(mocksim PUBLIC msim/include)
+  add_executable(msim examples/msim.cpp)
+  target_link_libraries(msim mocksim)
+
+  set(_libs mocksim opmcommon
+    ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+
+  foreach( test test_msim test_msim_ACTIONX )
+     add_executable(${test} "tests/msim/${test}")
+     target_link_libraries(${test} ${_libs})
+     add_test(NAME ${test} COMMAND ${test})
+     set_tests_properties(${test} PROPERTIES WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/tests)
+
+     if(HAVE_DYNAMIC_BOOST_TEST)
+       set_target_properties(${test} PROPERTIES
+                             COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK)
+     endif()
+  endforeach()
+endif()
+
+# Build the compare utilities
+if(ENABLE_ECL_INPUT)
+  add_library(testutil STATIC
+              examples/test_util/EclFilesComparator.cpp
+              examples/test_util/EclIntegrationTest.cpp
+              examples/test_util/EclRegressionTest.cpp
+              examples/test_util/summaryComparator.cpp
+              examples/test_util/summaryIntegrationTest.cpp
+              examples/test_util/summaryRegressionTest.cpp)
+  target_link_libraries(testutil ecl)
+  add_executable(compareECL examples/test_util/compareECL.cpp)
+  target_link_libraries(compareECL testutil opmcommon)
+
+  # Add the tests
+  set(_libs testutil opmcommon
+            ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+  opm_add_test(test_compareSummary CONDITION ENABLE_ECL_INPUT
+                                   LIBRARIES ${_libs})
+  opm_add_test(test_EclFilesComparator CONDITION ENABLE_ECL_INPUT
+                                       LIBRARIES ${_libs})
+  if(HAVE_DYNAMIC_BOOST_TEST)
+    set_target_properties(test_compareSummary PROPERTIES
+                          COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK)
+    set_target_properties(test_EclFilesComparator PROPERTIES
+                          COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK)
+  endif()
+  install(TARGETS compareECL DESTINATION bin)
+endif()
+
 # Install build system files
 install(DIRECTORY cmake DESTINATION share/opm)
+
+# Install tab completion skeleton
+install(FILES etc/opm_bash_completion.sh.in DESTINATION share/opm/etc)

CMakeLists_files.cmake

@@ -46,12 +46,14 @@ if(ENABLE_ECL_INPUT)
     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/Aquifetp.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/Edit/EDITNNC.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
@@ -73,7 +75,13 @@ if(ENABLE_ECL_INPUT)
     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/ActionX.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionAST.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/Actions.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionParser.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionValue.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/Action/ASTNode.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
@@ -87,12 +95,16 @@ if(ENABLE_ECL_INPUT)
     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/SummaryState.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/WList.cpp
+    src/opm/parser/eclipse/EclipseState/Schedule/WListManager.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/WellTracerProperties.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
@@ -103,17 +115,19 @@ if(ENABLE_ECL_INPUT)
     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/PolyInjTables.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/UDQParams.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/ErrorGuard.cpp
     src/opm/parser/eclipse/Parser/ParseContext.cpp
     src/opm/parser/eclipse/Parser/Parser.cpp
     src/opm/parser/eclipse/Parser/ParserEnums.cpp
@@ -135,10 +149,9 @@ if(ENABLE_ECL_INPUT)
 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/AggregateConnectionData.cpp
+          src/opm/output/eclipse/AggregateGroupData.cpp
+          src/opm/output/eclipse/AggregateMSWData.cpp
           src/opm/output/eclipse/AggregateWellData.cpp
           src/opm/output/eclipse/CreateDoubHead.cpp
           src/opm/output/eclipse/CreateInteHead.cpp
@@ -148,11 +161,12 @@ if(ENABLE_ECL_OUTPUT)
           src/opm/output/eclipse/EclipseGridInspector.cpp
           src/opm/output/eclipse/EclipseIO.cpp
           src/opm/output/eclipse/InteHEAD.cpp
+          src/opm/output/eclipse/libECLRestart.cpp
           src/opm/output/eclipse/LinearisedOutputTable.cpp
+          src/opm/output/eclipse/LoadRestart.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
@@ -177,6 +191,7 @@ if(ENABLE_ECL_INPUT)
     tests/parser/ACTIONX.cpp
     tests/parser/ADDREGTests.cpp
     tests/parser/AquiferCTTests.cpp
+    tests/parser/AquifetpTests.cpp
     tests/parser/AqudimsTests.cpp
     tests/parser/AquanconTests.cpp
     tests/parser/BoxTests.cpp
@@ -205,6 +220,7 @@ if(ENABLE_ECL_INPUT)
     tests/parser/MULTREGTScannerTests.cpp
     tests/parser/OrderedMapTests.cpp
     tests/parser/ParseContextTests.cpp
+    tests/parser/ParseContext_EXIT1.cpp
     tests/parser/PORVTests.cpp
     tests/parser/RawKeywordTests.cpp
     tests/parser/RestartConfigTests.cpp
@@ -230,15 +246,17 @@ if(ENABLE_ECL_INPUT)
     tests/parser/UnitTests.cpp
     tests/parser/ValueTests.cpp
     tests/parser/WellSolventTests.cpp
+    tests/parser/WellTracerTests.cpp
     tests/parser/WellTests.cpp
+    tests/parser/WLIST.cpp
     tests/parser/WTEST.cpp)
 endif()
 if(ENABLE_ECL_OUTPUT)
   list (APPEND TEST_SOURCE_FILES
           tests/test_AggregateWellData.cpp
+          #The unit tests are not finished yet, will be added in a separate pullrequest soon
+          #tests/test_AggregateMSWData.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
@@ -272,6 +290,9 @@ if(ENABLE_ECL_OUTPUT)
           tests/table_deck.DATA
           tests/summary_deck_non_constant_porosity.DATA
           tests/SUMMARY_EFF_FAC.DATA
+          tests/SPE1CASE1.DATA
+          tests/SPE9_CP_PACKED.DATA
+          tests/SOFR_TEST.DATA
       )
 endif()
 
@@ -283,12 +304,6 @@ if(ENABLE_ECL_INPUT)
     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
@@ -300,12 +315,6 @@ if(ENABLE_ECL_INPUT)
     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
@@ -353,6 +362,7 @@ if(ENABLE_ECL_INPUT)
        opm/parser/eclipse/Units/UnitSystem.hpp
        opm/parser/eclipse/Units/Units.hpp
        opm/parser/eclipse/Units/Dimension.hpp
+       opm/parser/eclipse/Parser/ErrorGuard.hpp
        opm/parser/eclipse/Parser/ParserItem.hpp
        opm/parser/eclipse/Parser/Parser.hpp
        opm/parser/eclipse/Parser/ParserRecord.hpp
@@ -366,6 +376,7 @@ if(ENABLE_ECL_INPUT)
        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/Edit/EDITNNC.hpp
        opm/parser/eclipse/EclipseState/Grid/GridDims.hpp
        opm/parser/eclipse/EclipseState/Grid/TransMult.hpp
        opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp
@@ -385,6 +396,7 @@ if(ENABLE_ECL_INPUT)
        opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp
        opm/parser/eclipse/EclipseState/EndpointScaling.hpp
        opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp
        opm/parser/eclipse/EclipseState/Tables/PdvdTable.hpp
        opm/parser/eclipse/EclipseState/Tables/TlpmixpaTable.hpp
        opm/parser/eclipse/EclipseState/Tables/PvdgTable.hpp
@@ -394,8 +406,11 @@ if(ENABLE_ECL_INPUT)
        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/PlymwinjTable.hpp
        opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp
        opm/parser/eclipse/EclipseState/Tables/RsvdTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/SkprwatTable.hpp
+       opm/parser/eclipse/EclipseState/Tables/SkprpolyTable.hpp
        opm/parser/eclipse/EclipseState/Tables/SpecheatTable.hpp
        opm/parser/eclipse/EclipseState/Tables/SgcwmisTable.hpp
        opm/parser/eclipse/EclipseState/Tables/Sof2Table.hpp
@@ -445,16 +460,24 @@ if(ENABLE_ECL_INPUT)
        opm/parser/eclipse/EclipseState/EclipseConfig.hpp
        opm/parser/eclipse/EclipseState/Aquancon.hpp
        opm/parser/eclipse/EclipseState/AquiferCT.hpp
-       opm/parser/eclipse/EclipseState/Schedule/ActionX.hpp
+       opm/parser/eclipse/EclipseState/Aquifetp.hpp
+       opm/parser/eclipse/EclipseState/Schedule/Action/ActionAST.hpp
+       opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.hpp
+       opm/parser/eclipse/EclipseState/Schedule/Action/Actions.hpp
+       opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.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/WList.hpp
+       opm/parser/eclipse/EclipseState/Schedule/WListManager.hpp
        opm/parser/eclipse/EclipseState/Schedule/DynamicVector.hpp
+       opm/parser/eclipse/EclipseState/Schedule/SummaryState.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/WellTracerProperties.hpp
        opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp
        opm/parser/eclipse/EclipseState/Schedule/Group.hpp
        opm/parser/eclipse/EclipseState/Schedule/MessageLimits.hpp
@@ -478,7 +501,7 @@ if(ENABLE_ECL_INPUT)
        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/UDQParams.hpp
        opm/parser/eclipse/EclipseState/Schedule/UDQExpression.hpp
        opm/parser/eclipse/Deck/DeckItem.hpp
        opm/parser/eclipse/Deck/Deck.hpp
@@ -497,8 +520,12 @@ if(ENABLE_ECL_OUTPUT)
         opm/output/data/Cells.hpp
         opm/output/data/Solution.hpp
         opm/output/data/Wells.hpp
+        opm/output/eclipse/VectorItems/connection.hpp
         opm/output/eclipse/VectorItems/intehead.hpp
         opm/output/eclipse/VectorItems/well.hpp
+        opm/output/eclipse/AggregateGroupData.hpp
+        opm/output/eclipse/AggregateConnectionData.hpp
+        opm/output/eclipse/AggregateMSWData.hpp
         opm/output/eclipse/AggregateWellData.hpp
         opm/output/eclipse/CharArrayNullTerm.hpp
         opm/output/eclipse/DoubHEAD.hpp
@@ -506,20 +533,16 @@ if(ENABLE_ECL_OUTPUT)
         opm/output/eclipse/EclipseIO.hpp
         opm/output/eclipse/EclipseIOUtil.hpp
         opm/output/eclipse/InteHEAD.hpp
-        opm/output/eclipse/LogiHEAD.hpp
+        opm/output/eclipse/libECLRestart.hpp
         opm/output/eclipse/LinearisedOutputTable.hpp
+        opm/output/eclipse/LogiHEAD.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()

ExtraTests.cmake

@@ -49,6 +49,7 @@ list(APPEND EXTRA_TESTS EclipseStateTests)
 foreach (test BoxTest
               CheckDeckValidity
               EclipseGridCreateFromDeck
+	      EDITNNCTests
               IncludeTest
               IntegrationTests
               IOConfigIntegrationTest

GenerateKeywords.cmake

@@ -7,6 +7,7 @@ set(genkw_SOURCES src/opm/json/JsonObject.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/ErrorGuard.cpp
                   src/opm/parser/eclipse/Parser/ParseContext.cpp
                   src/opm/parser/eclipse/Parser/ParserEnums.cpp
                   src/opm/parser/eclipse/Parser/ParserItem.cpp

cmake/Modules/ConfigVars.cmake

@@ -78,7 +78,17 @@ function (configure_vars obj syntax filename verb)
 	  # write a CMake statements that warns if the value has changed
 	  if ("${syntax}" STREQUAL "CMAKE")
 		set (_db "\${") # to avoid parsing problems
-		file (APPEND "${filename}" "if (DEFINED ${_var} AND NOT \"${_db}${_var}}\" STREQUAL \"${${_var}}\")\n")
+		# special case: if we have a truth variable HAVE_ and this is
+		# either just defined (as is), or set to 1 explicitly, then both
+		# of these count as "true", so put in a check that also accepts
+		# both of these values.
+		if (("${_var}" MATCHES "^HAVE_.*") AND
+			 (("${${_var}}" STREQUAL "") OR ("${${_var}}" STREQUAL "1")))
+		  set (_cond "(\"${_db}${_var}}\" STREQUAL \"\") OR (\"${_db}${_var}}\" STREQUAL \"1\")")
+		else ()
+		  set (_cond "\"${_db}${_var}}\" STREQUAL \"${${_var}}\"")
+		endif ()
+		file (APPEND "${filename}" "if (DEFINED ${_var} AND NOT (${_cond}))\n")
 		file (APPEND "${filename}" "\tmessage (WARNING \"Incompatible value \\\"${_db}${_var}}\\\" of variable \\\"${_var}\\\"\")\n")
 		file (APPEND "${filename}" "endif ()\n")
 	  endif ()

cmake/Modules/FindAlberta.cmake

@@ -0,0 +1,46 @@
+find_library(ALBERTA_LTDL_LIB
+  NAMES ltdl
+  PATH_SUFFIXES lib lib32 lib64
+)
+find_path(ALBERTA_INCLUDE_DIR
+  NAMES alberta/alberta.h
+  PATHS ${ALBERTA_ROOT}
+  PATH_SUFFIXES alberta include NO_DEFAULT_PATH
+  DOC "Include path of Alberta")
+find_path(ALBERTA_INCLUDE_DIR
+  NAMES
+  alberta/alberta.h
+  PATHS /usr/local /opt
+  PATH_SUFFIXES alberta)
+#look for libraries
+find_library(ALBERTA_UTIL_LIB
+  NAMES alberta_util alberta_utilities
+  PATHS ${ALBERTA_ROOT}
+  PATH_SUFFIXES lib lib32 lib64
+  NO_DEFAULT_PATH)
+find_library(ALBERTA_UTIL_LIB
+  NAMES alberta_util alberta_utilities
+  PATH_SUFFIXES lib lib32 lib64)
+
+foreach(dim RANGE 1 9)
+  find_library(ALBERTA_${dim}D_LIB alberta_${dim}d
+    PATHS ${ALBERTA_ROOT}
+    PATH_SUFFIXES lib lib32 lib64
+    Cache FILEPATH DOC "Alberta lib for ${dim}D" NO_DEFAULT_PATH)
+  find_library(ALBERTA_${dim}D_LIB alberta_${dim}d  PATH_SUFFIXES lib lib32 lib64)
+  if(ALBERTA_${dim}D_LIB)
+    set(ALBERTA_LIBRARIES ${ALBERTA_LIBRARIES} ${ALBERTA_${dim}D_LIB})
+  endif()
+endforeach(dim RANGE 1 9)
+
+if(ALBERTA_LIBRARIES AND ALBERTA_INCLUDE_DIR)
+  set(ALBERTA_INCLUDE_DIRS ${ALBERTA_INCLUDE_DIR})
+  set(ALBERTA_LIBRARIES ${ALBERTA_LIBRARIES} ${ALBERTA_UTIL_LIB} ${ALBERTA_LTDL_LIB})
+  set(ALBERTA_FOUND ON)
+  set(Alberta_FOUND ON)
+  set(HAVE_ALBERTA 1)
+  set(DUNE_ALBERTA_VERSION 0x300)
+else()
+  set(ALBERTA_FOUND OFF)
+  set(Alberta_FOUND OFF)
+endif()

cmake/Modules/Finddune-grid.cmake

@@ -27,7 +27,8 @@ find_opm_package (
   dune-geometry REQUIRED;
   dune-uggrid;
   MPI;
-  UG
+  UG;
+  Alberta
   "
   # header to search for
   "dune/grid/onedgrid.hh"
@@ -55,7 +56,8 @@ int main (void) {
    HAVE_AMIRAMESH;
    HAVE_ALBERTA;
    HAVE_STDINT_H;
-   DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS
+   DUNE_GRID_EXPERIMENTAL_GRID_EXTENSIONS;
+   DUNE_ALBERTA_VERSION
   ")
 
 #debug_find_vars ("dune-grid")

cmake/Modules/OpmBashCompletion.cmake

@@ -0,0 +1,6 @@
+# Installs bash tab completion for a product
+macro(opm_add_bash_completion binary)
+  set(PRODUCT ${binary})
+  configure_file(${OPM_MACROS_ROOT}/etc/opm_bash_completion.sh.in ${binary}_bash_completion.sh @ONLY)
+  install(FILES ${PROJECT_BINARY_DIR}/${binary}_bash_completion.sh DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/bash_completion.d)
+endmacro()

cmake/Modules/OpmSatellites.cmake

@@ -65,7 +65,7 @@ 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))
+        if(HAVE_DYNAMIC_BOOST_TEST)
 	  set_target_properties (${_sat_NAME} PROPERTIES
 		  COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK
 	  )
@@ -316,6 +316,11 @@ macro(opm_add_test TestName)
         # run-only case occurs if the binary is already compiled by an
         # earlier test.)
         add_executable("${CURTEST_EXE_NAME}" ${CURTEST_EXCLUDE_FROM_ALL} ${CURTEST_SOURCES})
+        if(HAVE_DYNAMIC_BOOST_TEST)
+          set_target_properties (${CURTEST_EXE_NAME} PROPERTIES
+		  COMPILE_DEFINITIONS BOOST_TEST_DYN_LINK
+	  )
+	endif()
         target_link_libraries (${CURTEST_EXE_NAME} ${CURTEST_LIBRARIES})
 
         if(CURTEST_DEPENDS)
@@ -344,12 +349,12 @@ macro(opm_add_test TestName)
 
       # specify the dependencies between the tests
       if (CURTEST_TEST_DEPENDS)
-        set_tests_properties(${TestName} PROPERTIES DEPENDS "${CURTEST_TEST_DEPENDS}")
+        set_tests_properties(${_FANCY} PROPERTIES DEPENDS "${CURTEST_TEST_DEPENDS}")
       endif()
 
       # tell ctest how many cores it should reserve to run the test
       if (CURTEST_PROCESSORS)
-        set_tests_properties(${TestName} PROPERTIES PROCESSORS "${CURTEST_PROCESSORS}")
+        set_tests_properties(${_FANCY} PROPERTIES PROCESSORS "${CURTEST_PROCESSORS}")
       endif()
     endif()
 

cmake/Modules/UseOptimization.cmake

@@ -21,10 +21,28 @@ if (CXX_COMPAT_GCC)
   # disabled due to widespread bugs in the linker plugin
   option (WHOLE_PROG_OPTIM "Whole program optimization (lto)" OFF)
   if (WHOLE_PROG_OPTIM)
-	check_cxx_accepts_flag ("-flto" HAVE_LINK_OPTS)
-	if (HAVE_LINK_OPTS)
-	  list (APPEND _opt_flags "-flto")
-	endif (HAVE_LINK_OPTS)
+    check_cxx_accepts_flag ("-flto" HAVE_LINK_OPTS)
+    check_cxx_accepts_flag ("-fuse-linker-plugin" HAVE_LINK_PLUGIN)
+    if (HAVE_LINK_OPTS)
+      list (APPEND _opt_flags "-flto")
+    endif (HAVE_LINK_OPTS)
+    if (HAVE_LINK_PLUGIN)
+      list (APPEND _opt_flags "-fuse-linker-plugin")
+    endif (HAVE_LINK_PLUGIN)
+    if(HAVE_LINK_OPTS AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+      string(REPLACE "." ";" VERSION_LIST "${CMAKE_C_COMPILER_VERSION}")
+      list(GET VERSION_LIST 0 VER_MAJOR)
+      find_program(LTO_AR_COMMAND NAMES ${CMAKE_C_COMPILER}-ar gcc-ar-${VER_MAJOR} gcc-ar)
+      find_program(LTO_RANLIB_COMMAND NAMES ${CMAKE_C_COMPILER}-ranlib gcc-ranlib-${VER_MAJOR} gcc-ranlib)
+      if(LTO_AR_COMMAND)
+        set(CMAKE_AR ${LTO_AR_COMMAND})
+        message(STATUS "Using LTO-enabled ar: ${CMAKE_AR}")
+      endif()
+      if(LTO_RANLIB_COMMAND)
+        set(CMAKE_RANLIB ${LTO_RANLIB_COMMAND})
+        message(STATUS "Using LTO-enabled ranlib: ${CMAKE_RANLIB}")
+      endif()
+    endif()
   endif (WHOLE_PROG_OPTIM)
 
   # native instruction set tuning

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

@@ -29,11 +29,34 @@ if(NOT @opm-project_NAME@_FOUND)
   set (@opm-project_NAME@_LIBRARY_DIRS "@opm-project_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@")
   set (@opm-project_NAME@_LIBRARIES ${@opm-project_NAME@_LIBRARY} "@opm-project_LIBRARIES@")
+
+  # The purpose of this string replacement operation is to enable use of the
+  # generated opm-project-config.cmake file also in the situation where 'make
+  # install' has been invoked with the DESTDIR option:
+  #
+  # opm-common/build> cmake .. -DCMAKE_INSTALL_PREFIX=/real/prefix
+  # opm-common/budil> make install DESTDIR=/tmp/prefix
+  #
+  # downstream/build> cmake .. -DDEST_PREFIX=/tmp/prefix -DCMAKE_PREFIX_PATH=/tmp/prefix
+  # downstream/build> make install
+  #
+  # That way the downstream dependency can still use find_package( opm-common )
+  # even though the opm-common-config.cmake file is not internally consistent
+  # with it's own location in the filesystem.
+
+  if(DEST_PREFIX)
+    set(DEST_PREFIX "${DEST_PREFIX}${@opm-project_NAME@_PREFIX}")
+    string(REPLACE ${@opm-project_NAME@_PREFIX} ${DEST_PREFIX} @opm-project_NAME@_INCLUDE_DIRS "${@opm-project_NAME@_INCLUDE_DIRS}")
+    string(REPLACE ${@opm-project_NAME@_PREFIX} ${DEST_PREFIX} @opm-project_NAME@_LIBRARY_DIRS "${@opm-project_NAME@_LIBRARY_DIRS}")
+    string(REPLACE ${@opm-project_NAME@_PREFIX} ${DEST_PREFIX} @opm-project_NAME@_LIBRARY      "${@opm-project_NAME@_LIBRARY}")
+  endif()
+
+
+  set (HAVE_@opm-project_NAME_UC@ 1)
   mark_as_advanced (@opm-project_NAME@_LIBRARY)
 
   # not all projects have targets; conditionally add this part
@@ -71,12 +94,17 @@ 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
-  @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)
+  # The settings in this block do not mix well with the DEST_PREFIX
+  # setting.
+  if (NOT DEST_PREFIX)
+    # This is required to include OpmPackage
+    set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" @PREREQ_LOCATION@)
+
+    # extra code from variable OPM_PROJECT_EXTRA_CODE
+    @OPM_PROJECT_EXTRA_CODE@
+    # end extra code
+
+    include(@opm-project_NAME@-prereqs)
+  endif()
 endif()

debian/changelog

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

dune.module

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

etc/opm_bash_completion.sh.in

@@ -0,0 +1,60 @@
+# this snippet enables parameter completion via the tabulator key
+# for bash for opm products.
+
+# this is a bash readline completer for the case where a binary is
+# already known to be an eWoms simulator.
+_ewoms_parameter_completor()
+{
+    if test "$COMP_WORDS" == ""; then
+        return 0
+    fi
+
+    cmd="${COMP_WORDS[0]}"
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    fullcmd="$(which "$cmd")"
+    ALL_OPTS=$("$fullcmd" --help 2> /dev/null | grep '^ *--' | sed 's/ *\(--[a-zA-Z0-9\-]*\)=.*/\1=/')
+    ALL_OPTS=$(echo "$ALL_OPTS" | sed 's/^ *--help.*/--help/')
+    COMPREPLY=( $(compgen -A file -W "$ALL_OPTS" -- "${cur}") )
+}
+
+# this is a bash readline default completer which attempts to find out
+# if a given binary is an eWoms simulation. this needs to be set as a
+# default completer because the name of eWoms binaries cannot be known
+# a-priori.
+_ewoms_generic_parameter_completor()
+{
+    if test "$COMP_WORDS" == ""; then
+        return 0
+    fi
+
+    COMPREPLY=()
+    local cmd cur ALL_OPTS
+    cmd="${COMP_WORDS[0]}"
+    cur="${COMP_WORDS[COMP_CWORD]}"
+
+    fullcmd="$(which "$cmd")"
+    if test -z "$fullcmd" || \
+       ! test -x "$fullcmd" || \
+       (! test -f "$fullcmd" && ! test -h "$fullcmd" ) || \
+       ! test -r "$fullcmd" || \
+       ! grep -q "Ewoms[a-zA-Z0-9]*Simulator[a-zA-Z0-0]" "$fullcmd"
+    then
+        if test -n "$DEFAULT_COMPLETION_LOADER"; then
+            "$DEFAULT_COMPLETION_LOADER" $@
+        elif type -t _completion_loader 2>&1 > /dev/null; then
+            # the default DEFAULT_COMPLETION_LOADER variable has not
+            # been set and the _completion_loader function exists, so
+            # we use _completion_loader as the default completer.
+            _completion_loader $@
+        else
+            return 1
+        fi
+
+        return $?
+    fi
+
+    _ewoms_parameter_completor $@
+    return 0
+}
+
+complete -o nospace -F _ewoms_parameter_completor @PRODUCT@

examples/msim.cpp

@@ -0,0 +1,53 @@
+/*
+  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 <opm/output/eclipse/EclipseIO.hpp>
+
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+#include <opm/parser/eclipse/Parser/ParseContext.hpp>
+#include <opm/parser/eclipse/Parser/ErrorGuard.hpp>
+
+#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
+#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
+
+#include <opm/msim/msim.hpp>
+
+
+int main(int argc, char** argv) {
+    std::string deck_file = argv[1];
+    Opm::Parser parser;
+    Opm::ParseContext parse_context;
+    Opm::ErrorGuard error_guard;
+
+    Opm::Deck deck = parser.parseFile(deck_file, parse_context, error_guard);
+    Opm::EclipseState state(deck, parse_context, error_guard);
+    Opm::Schedule schedule(deck, state.getInputGrid(), state.get3DProperties(), state.runspec(), parse_context, error_guard);
+    Opm::SummaryConfig summary_config(deck, schedule, state.getTableManager(), parse_context, error_guard);
+
+    if (error_guard) {
+        error_guard.dump();
+        error_guard.terminate();
+    }
+
+    Opm::msim msim(state);
+    Opm::EclipseIO io(state, state.getInputGrid(), schedule, summary_config);
+    msim.run(schedule, io);
+}
+

examples/opmi.cpp

@@ -21,6 +21,7 @@
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
 #include <opm/parser/eclipse/Parser/ParseContext.hpp>
+#include <opm/parser/eclipse/Parser/ErrorGuard.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
 #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
@@ -30,16 +31,16 @@
 
 inline void loadDeck( const char * deck_file) {
     Opm::ParseContext parseContext;
+    Opm::ErrorGuard errors;
     Opm::Parser parser;
 
     std::cout << "Loading deck: " << deck_file << " ..... "; std::cout.flush();
-    auto deck = parser.parseFile(deck_file, parseContext);
+    auto deck = parser.parseFile(deck_file, parseContext, errors);
     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 );
+    Opm::EclipseState state( deck, parseContext, errors );
+    Opm::Schedule schedule( deck, state.getInputGrid(), state.get3DProperties(), state.runspec(), parseContext, errors);
+    Opm::SummaryConfig summary( deck, schedule, state.getTableManager( ), parseContext, errors );
     std::cout << "complete." << std::endl;
-
 }
 
 

examples/opmpack.cpp

@@ -22,6 +22,7 @@
 #include <boost/filesystem.hpp>
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
+#include <opm/parser/eclipse/Parser/ErrorGuard.hpp>
 #include <opm/parser/eclipse/Parser/ParseContext.hpp>
 #include <opm/parser/eclipse/Parser/InputErrorAction.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
@@ -29,9 +30,10 @@
 
 inline void pack_deck( const char * deck_file, std::ostream& os) {
     Opm::ParseContext parseContext(Opm::InputError::WARN);
+    Opm::ErrorGuard errors;
     Opm::Parser parser;
 
-    auto deck = parser.parseFile(deck_file, parseContext);
+    auto deck = parser.parseFile(deck_file, parseContext, errors);
     os << deck;
 
 }

examples/test_util/Deviation.hpp

@@ -0,0 +1,32 @@
+/*
+   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/>.
+   */
+
+#ifndef DEVIATION_HPP
+#define DEVIATION_HPP
+
+/*! \brief Deviation struct.
+    \details The member variables are default initialized to -1,
+             which is an invalid deviation value.
+ */
+struct Deviation {
+    double abs = -1; //!< Absolute deviation
+    double rel = -1; //!< Relative deviation
+};
+
+#endif

examples/test_util/EclFilesComparator.cpp

@@ -0,0 +1,300 @@
+/*
+   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 "EclFilesComparator.hpp"
+#include <opm/common/ErrorMacros.hpp>
+#include <opm/common/utility/numeric/calculateCellVol.hpp>
+
+#include <stdio.h>
+
+#include <set>
+#include <iostream>
+#include <iomanip>
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+
+#include <ert/ecl/ecl_file.h>
+#include <ert/ecl/ecl_grid.h>
+#include <ert/ecl/ecl_type.h>
+
+#include <ert/ecl_well/well_info.h>
+
+
+// helper macro to handle error throws or not
+#define HANDLE_ERROR(type, message) \
+  { \
+    if (throwOnError) \
+      OPM_THROW(type, message); \
+    else { \
+      std::cerr << message << std::endl; \
+      ++num_errors; \
+    } \
+  }
+
+
+namespace {
+    /*
+      This is just a basic survival test; we verify that the ERT well
+      loader which is used in Resinsight can load the well description
+      from the restart file.
+    */
+
+    void loadWells( const ecl_grid_type * grid , ecl_file_type * rst_file ) {
+        well_info_type * well_info = well_info_alloc( grid );
+        well_info_add_UNRST_wells2( well_info , ecl_file_get_global_view( rst_file ), true );
+        well_info_free( well_info );
+    }
+
+}
+
+
+void ECLFilesComparator::keywordValidForComparing(const std::string& keyword) const {
+    auto it = std::find(keywords1.begin(), keywords1.end(), keyword);
+    if (it == keywords1.end()) {
+        OPM_THROW(std::runtime_error, "Keyword " << keyword << " does not exist in first file.");
+    }
+    it = find(keywords2.begin(), keywords2.end(), keyword);
+    if (it == keywords2.end()) {
+        OPM_THROW(std::runtime_error, "Keyword " << keyword << " does not exist in second file.");
+    }
+}
+
+
+unsigned int ECLFilesComparator::getEclKeywordData(ecl_kw_type*& ecl_kw1, ecl_kw_type*& ecl_kw2, const std::string& keyword, int occurrence1, int occurrence2) const {
+    ecl_kw1 = ecl_file_iget_named_kw(ecl_file1, keyword.c_str(), occurrence1);
+    ecl_kw2 = ecl_file_iget_named_kw(ecl_file2, keyword.c_str(), occurrence2);
+    const unsigned int numCells1 = ecl_kw_get_size(ecl_kw1);
+    const unsigned int numCells2 = ecl_kw_get_size(ecl_kw2);
+    if (numCells1 != numCells2) {
+        OPM_THROW(std::runtime_error, "For keyword " << keyword << ":"
+                << "\nOccurrence in first file " << occurrence1
+                << "\nOccurrence in second file " << occurrence2
+                << "\nCells in first file: " << numCells1
+                << "\nCells in second file: " << numCells2
+                << "\nThe number of cells differ.");
+    }
+    return numCells1;
+}
+
+
+
+template <typename T>
+void ECLFilesComparator::printValuesForCell(const std::string& /*keyword*/, int occurrence1, int occurrence2, size_t kw_size, size_t cell, const T& value1, const T& value2) const {
+    if (kw_size == static_cast<size_t>(ecl_grid_get_active_size(ecl_grid1))) {
+        int i, j, k;
+        ecl_grid_get_ijk1A(ecl_grid1, cell, &i, &j, &k);
+        // Coordinates from this function are zero-based, hence incrementing
+        i++, j++, k++;
+        std::cout << std::endl
+                  << "Occurrence in first file    = "  << occurrence1 << "\n"
+                  << "Occurrence in second file   = "  << occurrence2 << "\n"
+                  << "Value index                 = "  << cell << "\n"
+                  << "Grid coordinate             = (" << i << ", " << j << ", " << k << ")" << "\n"
+                  << "(first value, second value) = (" << value1 << ", " << value2 << ")\n\n";
+
+        return;
+    }
+
+    if (kw_size == static_cast<size_t>(ecl_grid_get_global_size(ecl_grid1))) {
+        int i, j, k;
+        ecl_grid_get_ijk1(ecl_grid1, cell, &i, &j, &k);
+        // Coordinates from this function are zero-based, hence incrementing
+        i++, j++, k++;
+        std::cout << std::endl
+                  << "Occurrence in first file    = "  << occurrence1 << "\n"
+                  << "Occurrence in second file   = "  << occurrence2 << "\n"
+                  << "Value index                 = "  << cell << "\n"
+                  << "Grid coordinate             = (" << i << ", " << j << ", " << k << ")" << "\n"
+                  << "(first value, second value) = (" << value1 << ", " << value2 << ")\n\n";
+        return;
+    }
+
+    std::cout << std::endl
+              << "Occurrence in first file    = "  << occurrence1 << "\n"
+              << "Occurrence in second file   = "  << occurrence2 << "\n"
+              << "Value index                 = "  << cell << "\n"
+              << "(first value, second value) = (" << value1 << ", " << value2 << ")\n\n";
+}
+
+template void ECLFilesComparator::printValuesForCell<bool>       (const std::string& keyword, int occurrence1, int occurrence2, size_t kw_size, size_t cell, const bool&        value1, const bool&        value2) const;
+template void ECLFilesComparator::printValuesForCell<int>        (const std::string& keyword, int occurrence1, int occurrence2, size_t kw_size, size_t cell, const int&         value1, const int&         value2) const;
+template void ECLFilesComparator::printValuesForCell<double>     (const std::string& keyword, int occurrence1, int occurrence2, size_t kw_size, size_t cell, const double&      value1, const double&      value2) const;
+template void ECLFilesComparator::printValuesForCell<std::string>(const std::string& keyword, int occurrence1, int occurrence2, size_t kw_size, size_t cell, const std::string& value1, const std::string& value2) const;
+
+
+ECLFilesComparator::ECLFilesComparator(int file_type_arg, const std::string& basename1,
+                                       const std::string& basename2,
+                                       double absToleranceArg, double relToleranceArg) :
+ file_type(file_type_arg), absTolerance(absToleranceArg), relTolerance(relToleranceArg) {
+
+    std::string file1, file2;
+    if (file_type == ECL_UNIFIED_RESTART_FILE) {
+        file1 = basename1 + ".UNRST";
+        file2 = basename2 + ".UNRST";
+    }
+    else if (file_type == ECL_INIT_FILE) {
+        file1 = basename1 + ".INIT";
+        file2 = basename2 + ".INIT";
+    }
+    else if (file_type == ECL_RFT_FILE) {
+        file1 = basename1 + ".RFT";
+        file2 = basename2 + ".RFT";
+    }
+    else {
+        OPM_THROW(std::invalid_argument, "Unsupported filetype sent to ECLFilesComparator's constructor."
+                << "Only unified restart (.UNRST), initial (.INIT) and .RFT files are supported.");
+    }
+    ecl_file1 = ecl_file_open(file1.c_str(), 0);
+    ecl_file2 = ecl_file_open(file2.c_str(), 0);
+    ecl_grid1 = ecl_grid_load_case(basename1.c_str());
+    ecl_grid2 = ecl_grid_load_case(basename2.c_str());
+    if (ecl_file1 == nullptr) {
+        OPM_THROW(std::invalid_argument, "Error opening first file: " << file1);
+    }
+    if (ecl_file2 == nullptr) {
+        OPM_THROW(std::invalid_argument, "Error opening second file: " << file2);
+    }
+    if (ecl_grid1 == nullptr) {
+        OPM_THROW(std::invalid_argument, "Error opening first grid file: " << basename1);
+    }
+    if (ecl_grid2 == nullptr) {
+        OPM_THROW(std::invalid_argument, "Error opening second grid file. " << basename2);
+    }
+    unsigned int numKeywords1 = ecl_file_get_num_distinct_kw(ecl_file1);
+    unsigned int numKeywords2 = ecl_file_get_num_distinct_kw(ecl_file2);
+    keywords1.reserve(numKeywords1);
+    keywords2.reserve(numKeywords2);
+    for (unsigned int i = 0; i < numKeywords1; ++i) {
+        std::string keyword(ecl_file_iget_distinct_kw(ecl_file1, i));
+        keywords1.push_back(keyword);
+    }
+    for (unsigned int i = 0; i < numKeywords2; ++i) {
+        std::string keyword(ecl_file_iget_distinct_kw(ecl_file2, i));
+        keywords2.push_back(keyword);
+    }
+
+    if (file_type == ECL_UNIFIED_RESTART_FILE) {
+        loadWells( ecl_grid1 , ecl_file1 );
+        loadWells( ecl_grid2 , ecl_file2 );
+    }
+}
+
+
+
+ECLFilesComparator::~ECLFilesComparator() {
+    ecl_file_close(ecl_file1);
+    ecl_file_close(ecl_file2);
+    ecl_grid_free(ecl_grid1);
+    ecl_grid_free(ecl_grid2);
+}
+
+
+
+void ECLFilesComparator::printKeywords() const {
+    std::cout << "\nKeywords in the first file:\n";
+    for (const auto& it : keywords1) {
+        std::cout << std::setw(15) << std::left << it << " of type " << ecl_type_get_name( ecl_file_iget_named_data_type(ecl_file1, it.c_str(), 0)) << std::endl;
+    }
+    std::cout << "\nKeywords in second file:\n";
+    for (const auto& it : keywords2) {
+        std::cout << std::setw(15) << std::left << it << " of type " << ecl_type_get_name( ecl_file_iget_named_data_type(ecl_file2, it.c_str(), 0)) << std::endl;
+    }
+}
+
+
+
+void ECLFilesComparator::printKeywordsDifference() const {
+    std::vector<std::string> common;
+    std::vector<std::string> uncommon;
+    const std::vector<std::string>* keywordsShort = &keywords1;
+    const std::vector<std::string>* keywordsLong = &keywords2;
+    if (keywords1.size() > keywords2.size()) {
+        keywordsLong = &keywords1;
+        keywordsShort = &keywords2;
+    }
+    for (const auto& it : *keywordsLong) {
+        const auto position = std::find(keywordsShort->begin(), keywordsShort->end(), it);
+        if (position != keywordsShort->end()) {
+            common.push_back(*position);
+        }
+        else {
+            uncommon.push_back(it);
+        }
+    }
+    std::cout << "\nCommon keywords for the two cases:\n";
+    for (const auto& it : common) std::cout << it << std::endl;
+    std::cout << "\nUncommon keywords for the two cases:\n";
+    for (const auto& it : uncommon) std::cout << it << std::endl;
+}
+
+
+
+Deviation ECLFilesComparator::calculateDeviations(double val1, double val2) {
+    val1 = std::abs(val1);
+    val2 = std::abs(val2);
+    Deviation deviation;
+    if (val1 != 0 || val2 != 0) {
+        deviation.abs = std::abs(val1 - val2);
+        if (val1 != 0 && val2 != 0) {
+            deviation.rel = deviation.abs/(std::max(val1, val2));
+        }
+    }
+    return deviation;
+}
+
+
+
+double ECLFilesComparator::median(std::vector<double> vec) {
+    if (vec.empty()) {
+        return 0;
+    }
+    else {
+        size_t n = vec.size()/2;
+        nth_element(vec.begin(), vec.begin() + n, vec.end());
+        if (vec.size() % 2 == 0) {
+            return 0.5*(vec[n-1]+vec[n]);
+        }
+        else {
+            return vec[n];
+        }
+    }
+}
+
+
+
+double ECLFilesComparator::average(const std::vector<double>& vec) {
+    if (vec.empty()) {
+        return 0;
+    }
+    double sum = std::accumulate(vec.begin(), vec.end(), 0.0);
+    return sum/vec.size();
+}
+
+
+
+double ECLFilesComparator::getCellVolume(const ecl_grid_type* ecl_grid,
+                                         const int globalIndex) {
+    std::vector<double> x(8, 0.0);
+    std::vector<double> y(8, 0.0);
+    std::vector<double> z(8, 0.0);
+    for (int i = 0; i < 8; i++) {
+        ecl_grid_get_cell_corner_xyz1(ecl_grid, globalIndex, i, &x.data()[i], &y.data()[i], &z.data()[i]);
+    }
+    return calculateCellVol(x,y,z);
+}

examples/test_util/EclFilesComparator.hpp

@@ -0,0 +1,127 @@
+/*
+   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/>.
+   */
+
+#ifndef ECLFILESCOMPARATOR_HPP
+#define ECLFILESCOMPARATOR_HPP
+
+#include "Deviation.hpp"
+#include <map>
+#include <vector>
+#include <string>
+
+struct ecl_file_struct; //!< Prototype for eclipse file struct, from ERT library.
+typedef struct ecl_file_struct ecl_file_type;
+
+struct ecl_grid_struct; //!< Prototype for eclipse grid struct, from ERT library.
+typedef struct ecl_grid_struct ecl_grid_type;
+struct ecl_kw_struct; //!< Prototype for eclipse keyword struct, from ERT library.
+typedef struct ecl_kw_struct ecl_kw_type;
+
+
+/*! \brief A class for comparing ECLIPSE files.
+    \details ECLFilesComparator opens ECLIPSE files
+             (unified restart, initial and RFT in addition to grid file)
+             from two simulations. This class has only the functions
+             printKeywords() and printKeywordsDifference(), in addition to a
+             couple of get-functions: the comparison logic is implemented in
+             the subclasses RegressionTest and IntegrationTest. */
+class ECLFilesComparator {
+    private:
+        int file_type;
+        double absTolerance      = 0;
+        double relTolerance      = 0;
+    protected:
+        ecl_file_type* ecl_file1 = nullptr;
+        ecl_grid_type* ecl_grid1 = nullptr;
+        ecl_file_type* ecl_file2 = nullptr;
+        ecl_grid_type* ecl_grid2 = nullptr;
+        std::vector<std::string> keywords1, keywords2;
+        bool throwOnError = true; //!< Throw on first error
+        bool analysis = false; //!< Perform full error analysis
+        std::map<std::string, std::vector<Deviation>> deviations;
+        mutable size_t num_errors = 0;
+
+        //! \brief Checks if the keyword exists in both cases.
+        //! \param[in] keyword Keyword to check.
+        //! \details If the keyword does not exist in one of the cases, the function throws an exception.
+        void keywordValidForComparing(const std::string& keyword) const;
+        //! \brief Stores keyword data for a given occurrence
+        //! \param[out] ecl_kw1 Pointer to a ecl_kw_type, which stores keyword data for first case given the occurrence.
+        //! \param[out] ecl_kw2 Pointer to a ecl_kw_type, which stores keyword data for second case given the occurrence.
+        //! \param[in] keyword Which keyword to consider.
+        //! \param[in] occurrence Which keyword occurrence to consider.
+        //! \details This function stores keyword data for the given keyword and occurrence in #ecl_kw1 and #ecl_kw2, and returns the number of cells (for which the keyword has a value at the occurrence). If the number of cells differ for the two cases, an exception is thrown.
+        unsigned int getEclKeywordData(ecl_kw_type*& ecl_kw1, ecl_kw_type*& ecl_kw2, const std::string& keyword, int occurrence1, int occurrence2) const;
+        //! \brief Prints values for a given keyword, occurrence and cell
+        //! \param[in] keyword Which keyword to consider.
+        //! \param[in] occurrence Which keyword occurrence to consider.
+        //! \param[in] cell Which cell occurrence to consider (numbered by global index).
+        //! \param[in] value1 Value for first file, the data type can be bool, int, double or std::string.
+        //! \param[in] value2 Value for second file, the data type can be bool, int, double or std::string.
+        //! \details Templatefunction for printing values when exceptions are thrown. The function is defined for bool, int, double and std::string.
+        template <typename T>
+        void printValuesForCell(const std::string& keyword, int occurrence1, int occurrence2, size_t kw_size, size_t cell, const T& value1, const T& value2) const;
+
+    public:
+        //! \brief Open ECLIPSE files and set tolerances and keywords.
+        //! \param[in] file_type Specifies which filetype to be compared, possible inputs are UNRSTFILE, INITFILE and RFTFILE.
+        //! \param[in] basename1 Full path without file extension to the first case.
+        //! \param[in] basename2 Full path without file extension to the second case.
+        //! \param[in] absTolerance Tolerance for absolute deviation.
+        //! \param[in] relTolerance Tolerance for relative deviation.
+        //! \details The content of the ECLIPSE files specified in the input is stored in the ecl_file_type and ecl_grid_type member variables. In addition the keywords and absolute and relative tolerances (member variables) are set. If the constructor is unable to open one of the ECLIPSE files, an exception will be thrown.
+        ECLFilesComparator(int file_type, const std::string& basename1, const std::string& basename2, double absTolerance, double relTolerance);
+        //! \brief Closing the ECLIPSE files.
+        ~ECLFilesComparator();
+
+        //! \brief Set whether to throw on errors or not.
+        void throwOnErrors(bool dothrow) { throwOnError = dothrow; }
+
+        //! \brief Set whether to perform a full error analysis.
+        void doAnalysis(bool analize) { analysis = analize; }
+
+        //! \brief Returns the number of errors encountered in the performed comparisons.
+        size_t getNoErrors() const { return num_errors; }
+
+        //! \brief Returns the ECLIPSE filetype of this
+        int getFileType() const {return file_type;}
+        //! \brief Returns the absolute tolerance stored as a private member variable in the class
+        double getAbsTolerance() const {return absTolerance;}
+        //! \brief Returns the relative tolerance stored as a private member variable in the class
+        double getRelTolerance() const {return relTolerance;}
+
+        //! \brief Print all keywords and their respective Eclipse type for the two input cases.
+        void printKeywords() const;
+        //! \brief Print common and uncommon keywords for the two input cases.
+        void printKeywordsDifference() const;
+
+        //! \brief Calculate deviations for two values.
+        //! \details Using absolute values of the input arguments: If one of the values are non-zero, the Deviation::abs returned is the difference between the two input values. In addition, if both values are non-zero, the Deviation::rel returned is the absolute deviation divided by the largest value.
+        static Deviation calculateDeviations(double val1, double val2);
+        //! \brief Calculate median of a vector.
+        //! \details Returning the median of the input vector, i.e. the middle value of the sorted vector if the number of elements is odd or the mean of the two middle values if the number of elements are even.
+        static double median(std::vector<double> vec);
+        //! \brief Calculate average of a vector.
+        //! \details Returning the average of the input vector, i.e. the sum of all values divided by the number of elements.
+        static double average(const std::vector<double>& vec);
+         //! \brief Obtain the volume of a cell.
+        static double getCellVolume(const ecl_grid_type* ecl_grid, const int globalIndex);
+};
+
+#endif

examples/test_util/EclIntegrationTest.cpp

@@ -0,0 +1,199 @@
+/*
+   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 "EclIntegrationTest.hpp"
+#include <opm/common/ErrorMacros.hpp>
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <set>
+
+#include <ert/ecl/ecl_file.h>
+#include <ert/ecl/ecl_grid.h>
+#include <ert/ecl/ecl_type.h>
+
+#include <ert/ecl_well/well_info.h>
+
+
+// helper macro to handle error throws or not
+#define HANDLE_ERROR(type, message) \
+  { \
+    if (throwOnError) \
+      OPM_THROW(type, message); \
+    else { \
+      std::cerr << message << std::endl; \
+      ++num_errors; \
+    } \
+  }
+
+
+void ECLIntegrationTest::setCellVolumes() {
+    double absTolerance = getAbsTolerance();
+    double relTolerance = getRelTolerance();
+    const unsigned int globalGridCount1 = ecl_grid_get_global_size(ecl_grid1);
+    const unsigned int activeGridCount1 = ecl_grid_get_active_size(ecl_grid1);
+    const unsigned int globalGridCount2 = ecl_grid_get_global_size(ecl_grid2);
+    const unsigned int activeGridCount2 = ecl_grid_get_active_size(ecl_grid2);
+    if (globalGridCount1 != globalGridCount2) {
+        OPM_THROW(std::runtime_error, "In grid file:"
+                << "\nCells in first file: "  << globalGridCount1
+                << "\nCells in second file: " << globalGridCount2
+                << "\nThe number of global cells differ.");
+    }
+    if (activeGridCount1 != activeGridCount2) {
+        OPM_THROW(std::runtime_error, "In grid file:"
+                << "\nCells in first file: "  << activeGridCount1
+                << "\nCells in second file: " << activeGridCount2
+                << "\nThe number of active cells differ.");
+    }
+    for (unsigned int cell = 0; cell < globalGridCount1; ++cell) {
+        const double cellVolume1 = getCellVolume(ecl_grid1, cell);
+        const double cellVolume2 = getCellVolume(ecl_grid2, cell);
+        Deviation dev = calculateDeviations(cellVolume1, cellVolume2);
+        if (dev.abs > absTolerance && dev.rel > relTolerance) {
+            int i, j, k;
+            ecl_grid_get_ijk1(ecl_grid1, cell, &i, &j, &k);
+            // Coordinates from this function are zero-based, hence incrementing
+            i++, j++, k++;
+            OPM_THROW(std::runtime_error, "In grid file: Deviations of cell volume exceed tolerances. "
+                    << "\nFor cell with coordinate (" << i << ", " << j << ", " << k << "):"
+                    << "\nCell volume in first file: "  << cellVolume1
+                    << "\nCell volume in second file: " << cellVolume2
+                    << "\nThe absolute deviation is " << dev.abs << ", and the tolerance limit is " << absTolerance << "."
+                    << "\nThe relative deviation is " << dev.rel << ", and the tolerance limit is " << relTolerance << ".");
+        } // The second input case is used as reference.
+        cellVolumes.push_back(cellVolume2);
+    }
+}
+
+
+
+void ECLIntegrationTest::initialOccurrenceCompare(const std::string& keyword) {
+    ecl_kw_type* ecl_kw1 = nullptr;
+    ecl_kw_type* ecl_kw2 = nullptr;
+    const unsigned int numCells = getEclKeywordData(ecl_kw1, ecl_kw2, keyword, 0, 0);
+    std::vector<double> values1(numCells);
+    initialCellValues.resize(numCells);
+
+    ecl_kw_get_data_as_double(ecl_kw1, values1.data());
+    ecl_kw_get_data_as_double(ecl_kw2, initialCellValues.data());
+
+    // This variable sums up the difference between the keyword value for the first case and the keyword value for the second case, for each cell. The sum is weighted with respect to the cell volume of each cell.
+    double weightedDifference = 0;
+    // This variable sums up the keyword value for the first case for each cell. The sum is weighted with respect to the cell volume of each cell.
+    double weightedTotal = 0;
+    for (size_t cell = 0; cell < initialCellValues.size(); ++cell) {
+        weightedTotal += initialCellValues[cell]*cellVolumes[cell];
+        weightedDifference += std::abs(values1[cell] - initialCellValues[cell])*cellVolumes[cell];
+    }
+    if (weightedTotal != 0) {
+        double ratioValue = weightedDifference/weightedTotal;
+        if ((ratioValue) > getRelTolerance()) {
+            OPM_THROW(std::runtime_error, "\nFor keyword " << keyword << " and occurrence 0:"
+                    << "\nThe ratio of the deviation and the total value is " << ratioValue
+                    << ", which exceeds the relative tolerance of " << getRelTolerance() << "."
+                    << "\nSee the docs for more information about how the ratio is computed.");
+        }
+    }
+}
+
+
+
+void ECLIntegrationTest::occurrenceCompare(const std::string& keyword, int occurrence) const {
+    ecl_kw_type* ecl_kw1 = nullptr;
+    ecl_kw_type* ecl_kw2 = nullptr;
+    const unsigned int numCells = getEclKeywordData(ecl_kw1, ecl_kw2, keyword, occurrence, occurrence);
+    std::vector<double> values1(numCells), values2(numCells);
+    ecl_kw_get_data_as_double(ecl_kw1, values1.data());
+    ecl_kw_get_data_as_double(ecl_kw2, values2.data());
+
+    // This variable sums up the difference between the keyword value for the first case and the keyword value for the second case, for each cell. The sum is weighted with respect to the cell volume of each cell.
+    double weightedDifference = 0;
+    // This variable sums up the difference between the keyword value for the occurrence and the initial keyword value for each cell. The sum is weighted with respect to the cell volume of each cell.
+    double relativeWeightedTotal = 0;
+
+    for (size_t cell = 0; cell < values1.size(); ++cell) {
+        relativeWeightedTotal += std::abs(values1[cell] - initialCellValues[cell])*cellVolumes[cell];
+        weightedDifference += std::abs(values1[cell] - values2[cell])*cellVolumes[cell];
+    }
+
+    if (relativeWeightedTotal != 0) {
+        double ratioValue = weightedDifference/relativeWeightedTotal;
+        if ((ratioValue) > getRelTolerance()) {
+            OPM_THROW(std::runtime_error, "\nFor keyword " << keyword << " and occurrence " << occurrence << ":"
+                    << "\nThe ratio of the deviation and the total value is " << ratioValue
+                    << ", which exceeds the relative tolerance of " << getRelTolerance() << "."
+                    << "\nSee the docs for more information about how the ratio is computed.");
+        }
+    }
+}
+
+
+
+ECLIntegrationTest::ECLIntegrationTest(const std::string& basename1,
+                                       const std::string& basename2,
+                                       double absTolerance, double relTolerance) :
+    ECLFilesComparator(ECL_UNIFIED_RESTART_FILE, basename1, basename2, absTolerance, relTolerance) {
+    std::cout << "\nUsing cell volumes and keyword values from case " << basename2
+              << " as reference." << std::endl << std::endl;
+    setCellVolumes();
+}
+
+
+
+bool ECLIntegrationTest::elementInWhitelist(const std::string& keyword) const {
+    auto it = std::find(keywordWhitelist.begin(), keywordWhitelist.end(), keyword);
+    return it != keywordWhitelist.end();
+}
+
+
+
+void ECLIntegrationTest::equalNumKeywords() const {
+    if (keywords1.size() != keywords2.size()) {
+        OPM_THROW(std::runtime_error, "\nKeywords in first file: " << keywords1.size()
+                << "\nKeywords in second file: " << keywords2.size()
+                << "\nThe number of keywords differ.");
+    }
+}
+
+
+
+void ECLIntegrationTest::results() {
+    for (const auto& it : keywordWhitelist)
+        resultsForKeyword(it);
+}
+
+
+
+void ECLIntegrationTest::resultsForKeyword(const std::string& keyword) {
+    std::cout << "Comparing " << keyword << "...";
+    keywordValidForComparing(keyword);
+    const unsigned int occurrences1 = ecl_file_get_num_named_kw(ecl_file1, keyword.c_str());
+    const unsigned int occurrences2 = ecl_file_get_num_named_kw(ecl_file2, keyword.c_str());
+    if (occurrences1 != occurrences2) {
+        OPM_THROW(std::runtime_error, "For keyword " << keyword << ":"
+                << "\nKeyword occurrences in first file: "  << occurrences1
+                << "\nKeyword occurrences in second file: " << occurrences2
+                << "\nThe number of occurrences differ.");
+    }
+    initialOccurrenceCompare(keyword);
+    for (unsigned int occurrence = 1; occurrence < occurrences1; ++occurrence) {
+        occurrenceCompare(keyword, occurrence);
+    }
+    std::cout << "done." << std::endl;
+}

examples/test_util/EclIntegrationTest.hpp

@@ -0,0 +1,78 @@
+/*
+   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/>.
+   */
+
+#ifndef ECLINTEGRATIONTEST_HPP
+#define ECLINTEGRATIONTEST_HPP
+
+#include "EclFilesComparator.hpp"
+
+/*! \brief A class for executing a integration test for two ECLIPSE files.
+    \details This class inherits from ECLFilesComparator, which opens and closes
+             the input cases and stores keywordnames. The three public functions
+             equalNumKeywords(), results() and resultsForKeyword() can be invoked
+             to compare griddata or keyworddata for all keywords or a given
+             keyword (resultsForKeyword()).
+*/
+class ECLIntegrationTest: public ECLFilesComparator {
+    private:
+        std::vector<double> cellVolumes; //!< Vector of cell volumes in second input case (indexed by global index)
+        std::vector<double> initialCellValues; //!< Keyword values for all cells at first occurrence (index by global index)
+
+        // These are the only keywords which are compared, since SWAT should be "1 - SOIL - SGAS", this keyword is omitted.
+        const std::vector<std::string> keywordWhitelist = {"SGAS", "SWAT", "PRESSURE"};
+
+        void setCellVolumes();
+        void initialOccurrenceCompare(const std::string& keyword);
+        void occurrenceCompare(const std::string& keyword, int occurrence) const;
+    public:
+        //! \brief Sets up the integration test.
+        //! \param[in] basename1 Full path without file extension to the first case.
+        //! \param[in] basename2 Full path without file extension to the second case.
+        //! \param[in] absTolerance Tolerance for absolute deviation.
+        //! \param[in] relTolerance Tolerance for relative deviation.
+        //! \details This constructor calls the constructor of the superclass, with input filetype unified restart. See the docs for ECLFilesComparator for more information.
+        ECLIntegrationTest(const std::string& basename1, const std::string& basename2, double absTolerance, double relTolerance);
+
+        //! \brief Checks if a keyword is supported for comparison.
+        //! \param[in] keyword Keyword to check.
+        bool elementInWhitelist(const std::string& keyword) const;
+        //! \brief Checks if the number of keywords equal in the two input cases.
+        //! \param[in] keyword Keyword to check.
+        void equalNumKeywords() const;
+
+        //! \brief Finds deviations for all supported keywords.
+        //! \details results() loops through all supported keywords for integration test (defined in keywordWhitelist -- this is SGAS, SWAT and PRESSURE) and calls resultsForKeyword() for each keyword.
+        void results();
+        //! \brief Finds deviations for a specific keyword.
+        //! \param[in] keyword Keyword to check.
+        /*! \details First, resultsForKeyword() checks if the keyword exits in both cases, and if the number of keyword occurrences in the two cases differ. If these tests fail, an exception is thrown. Then deviaitons are calculated as described below for each occurrence, and an exception is thrown if the relative error ratio \f$E\f$ is larger than the relative tolerance.
+        * Calculation:\n
+        * Let the keyword values for occurrence \f$n\f$ and cell \f$i\f$ be \f$p_{n,i}\f$ and \f$q_{n,i}\f$ for input case 1 and 2, respectively.
+        * Consider first the initial occurrence (\f$n=0\f$). The function uses the second cases as reference, and calculates the volume weighted sum of \f$q_{0,i}\f$ over all cells \f$i\f$:
+        * \f[ S_0 = \sum_{i} q_{0,i} v_i \f]
+        * where \f$v_{i}\f$ is the volume of cell \f$i\f$ in case 2. Then, the deviations between the cases for each cell are calculated:
+        * \f[ \Delta = \sum_{i} |p_{0,i} - q_{0,i}| v_i.\f]
+        * The error ratio is then \f$E = \Delta/S_0\f$.\n
+        * For all other occurrences \f$n\f$, the deviation value \f$\Delta\f$ is calculated the same way, but the total value \f$S\f$ is calculated relative to the initial occurrence total \f$S_0\f$:
+        * \f[ S = \sum_{i} |q_{n,i} - q_{0,i}| v_i. \f]
+        * The error ratio is \f$ E = \Delta/S\f$. */
+        void resultsForKeyword(const std::string& keyword);
+};
+
+#endif

examples/test_util/EclRegressionTest.cpp

@@ -0,0 +1,352 @@
+/*
+   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 "EclRegressionTest.hpp"
+#include <opm/common/ErrorMacros.hpp>
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <set>
+
+#include <ert/ecl/ecl_file.h>
+#include <ert/ecl/ecl_grid.h>
+#include <ert/ecl/ecl_type.h>
+
+#include <ert/ecl_well/well_info.h>
+
+
+// helper macro to handle error throws or not
+#define HANDLE_ERROR(type, message) \
+  { \
+    if (throwOnError) \
+      OPM_THROW(type, message); \
+    else { \
+      std::cerr << message << std::endl; \
+      ++num_errors; \
+    } \
+  }
+
+
+void ECLRegressionTest::printResultsForKeyword(const std::string& keyword) const {
+    std::cout << "Deviation results for keyword " << keyword << " of type "
+        << ecl_type_get_name(ecl_file_iget_named_data_type(ecl_file1, keyword.c_str(), 0))
+        << ":\n";
+    const double absDeviationAverage = average(absDeviation);
+    const double relDeviationAverage = average(relDeviation);
+    std::cout << "Average absolute deviation = " << absDeviationAverage  << std::endl;
+    std::cout << "Median absolute deviation  = " << median(absDeviation) << std::endl;
+    std::cout << "Average relative deviation = " << relDeviationAverage  << std::endl;
+    std::cout << "Median relative deviation  = " << median(relDeviation) << "\n\n";
+}
+
+
+
+void ECLRegressionTest::boolComparisonForOccurrence(const std::string& keyword,
+                                                    int occurrence1, int occurrence2) const {
+    ecl_kw_type* ecl_kw1 = nullptr;
+    ecl_kw_type* ecl_kw2 = nullptr;
+    const unsigned int numCells = getEclKeywordData(ecl_kw1, ecl_kw2, keyword, occurrence1, occurrence2);
+    for (size_t cell = 0; cell < numCells; cell++) {
+        bool data1 = ecl_kw_iget_bool(ecl_kw1, cell);
+        bool data2 = ecl_kw_iget_bool(ecl_kw2, cell);
+        if (data1 != data2) {
+            printValuesForCell(keyword, occurrence1, occurrence2, numCells, cell, data1, data2);
+            HANDLE_ERROR(std::runtime_error, "Values of bool type differ.");
+        }
+    }
+}
+
+
+
+void ECLRegressionTest::charComparisonForOccurrence(const std::string& keyword,
+                                                    int occurrence1, int occurrence2) const {
+    ecl_kw_type* ecl_kw1 = nullptr;
+    ecl_kw_type* ecl_kw2 = nullptr;
+    const unsigned int numCells = getEclKeywordData(ecl_kw1, ecl_kw2, keyword, occurrence1, occurrence2);
+    for (size_t cell = 0; cell < numCells; cell++) {
+        std::string data1(ecl_kw_iget_char_ptr(ecl_kw1, cell));
+        std::string data2(ecl_kw_iget_char_ptr(ecl_kw2, cell));
+        if (data1.compare(data2) != 0) {
+            printValuesForCell(keyword, occurrence1, occurrence2, numCells, cell, data1, data2);
+            HANDLE_ERROR(std::runtime_error, "Values of char type differ.");
+        }
+    }
+}
+
+
+
+void ECLRegressionTest::intComparisonForOccurrence(const std::string& keyword,
+                                                   int occurrence1, int occurrence2) const {
+    ecl_kw_type* ecl_kw1 = nullptr;
+    ecl_kw_type* ecl_kw2 = nullptr;
+    const unsigned int numCells = getEclKeywordData(ecl_kw1, ecl_kw2, keyword, occurrence1, occurrence2);
+    std::vector<int> values1(numCells), values2(numCells);
+    ecl_kw_get_memcpy_int_data(ecl_kw1, values1.data());
+    ecl_kw_get_memcpy_int_data(ecl_kw2, values2.data());
+    for (size_t cell = 0; cell < values1.size(); cell++) {
+        if (values1[cell] != values2[cell]) {
+            printValuesForCell(keyword, occurrence1, occurrence2, values1.size(), cell, values1[cell], values2[cell]);
+            HANDLE_ERROR(std::runtime_error, "Values of int type differ.");
+        }
+    }
+}
+
+
+
+void ECLRegressionTest::doubleComparisonForOccurrence(const std::string& keyword,
+                                                      int occurrence1, int occurrence2) {
+    ecl_kw_type* ecl_kw1 = nullptr;
+    ecl_kw_type* ecl_kw2 = nullptr;
+    const unsigned int numCells = getEclKeywordData(ecl_kw1, ecl_kw2, keyword, occurrence1, occurrence2);
+    std::vector<double> values1(numCells), values2(numCells);
+    ecl_kw_get_data_as_double(ecl_kw1, values1.data());
+    ecl_kw_get_data_as_double(ecl_kw2, values2.data());
+
+    auto it = std::find(keywordDisallowNegatives.begin(), keywordDisallowNegatives.end(), keyword);
+    for (size_t cell = 0; cell < values1.size(); cell++) {
+        deviationsForCell(values1[cell], values2[cell], keyword, occurrence1, occurrence2, cell, it == keywordDisallowNegatives.end());
+    }
+}
+
+
+
+void ECLRegressionTest::deviationsForCell(double val1, double val2,
+                                          const std::string& keyword,
+                                          int occurrence1, int occurrence2,
+                                          size_t kw_size, size_t cell,
+                                          bool allowNegativeValues) {
+    double absTolerance = getAbsTolerance();
+    double relTolerance = getRelTolerance();
+    if (!allowNegativeValues) {
+        if (val1 < 0) {
+            if (std::abs(val1) > absTolerance) {
+                printValuesForCell(keyword, occurrence1, occurrence2, kw_size, cell, val1, val2);
+                HANDLE_ERROR(std::runtime_error, "Negative value in first file, "
+                        << "which in absolute value exceeds the absolute tolerance of " << absTolerance << ".");
+            }
+            val1 = 0;
+        }
+        if (val2 < 0) {
+            if (std::abs(val2) > absTolerance) {
+                printValuesForCell(keyword, occurrence1, occurrence2, kw_size, cell, val1, val2);
+                HANDLE_ERROR(std::runtime_error, "Negative value in second file, "
+                        << "which in absolute value exceeds the absolute tolerance of " << absTolerance << ".");
+            }
+            val2 = 0;
+        }
+    }
+    Deviation dev = calculateDeviations(val1, val2);
+    if (dev.abs > absTolerance && dev.rel > relTolerance) {
+        if (analysis) {
+          deviations[keyword].push_back(dev);
+        } else {
+            printValuesForCell(keyword, occurrence1, occurrence2, kw_size, cell, val1, val2);
+            HANDLE_ERROR(std::runtime_error, "Deviations exceed tolerances."
+                    << "\nThe absolute deviation is " << dev.abs << ", and the tolerance limit is " << absTolerance << "."
+                    << "\nThe relative deviation is " << dev.rel << ", and the tolerance limit is " << relTolerance << ".");
+        }
+    }
+    if (dev.abs != -1) {
+        absDeviation.push_back(dev.abs);
+    }
+    if (dev.rel != -1) {
+        relDeviation.push_back(dev.rel);
+    }
+}
+
+
+
+void ECLRegressionTest::gridCompare(const bool volumecheck) const {
+    double absTolerance = getAbsTolerance();
+    double relTolerance = getRelTolerance();
+    const unsigned int globalGridCount1 = ecl_grid_get_global_size(ecl_grid1);
+    const unsigned int activeGridCount1 = ecl_grid_get_active_size(ecl_grid1);
+    const unsigned int globalGridCount2 = ecl_grid_get_global_size(ecl_grid2);
+    const unsigned int activeGridCount2 = ecl_grid_get_active_size(ecl_grid2);
+    if (globalGridCount1 != globalGridCount2) {
+        OPM_THROW(std::runtime_error, "In grid file:"
+                << "\nCells in first file: "  << globalGridCount1
+                << "\nCells in second file: " << globalGridCount2
+                << "\nThe number of global cells differ.");
+    }
+    if (activeGridCount1 != activeGridCount2) {
+        OPM_THROW(std::runtime_error, "In grid file:"
+                << "\nCells in first file: "  << activeGridCount1
+                << "\nCells in second file: " << activeGridCount2
+                << "\nThe number of active cells differ.");
+    }
+
+    if (!volumecheck) {
+        return;
+    }
+
+    for (unsigned int cell = 0; cell < globalGridCount1; ++cell) {
+        const bool active1 = ecl_grid_cell_active1(ecl_grid1, cell);
+        const bool active2 = ecl_grid_cell_active1(ecl_grid2, cell);
+        if (active1 != active2) {
+            int i, j, k;
+            ecl_grid_get_ijk1(ecl_grid1, cell, &i, &j, &k);
+            // Coordinates from this function are zero-based, hence incrementing
+            i++, j++, k++;
+            HANDLE_ERROR(std::runtime_error, "Grid cell with one-based indices ( "
+                         << i << ", " << j << ", " << k << " ) is "
+                         << (active1 ? "active" : "inactive") << " in first grid, but "
+                         << (active2 ? "active" : "inactive") << " in second grid.");
+        }
+        const double cellVolume1 = getCellVolume(ecl_grid1, cell);
+        const double cellVolume2 = getCellVolume(ecl_grid2, cell);
+        Deviation dev = calculateDeviations(cellVolume1, cellVolume2);
+        if (dev.abs > absTolerance && dev.rel > relTolerance) {
+            int i, j, k;
+            ecl_grid_get_ijk1(ecl_grid1, cell, &i, &j, &k);
+            // Coordinates from this function are zero-based, hence incrementing
+            i++, j++, k++;
+            HANDLE_ERROR(std::runtime_error, "In grid file: Deviations of cell volume exceed tolerances. "
+                    << "\nFor cell with one-based indices (" << i << ", " << j << ", " << k << "):"
+                    << "\nCell volume in first file: "  << cellVolume1
+                    << "\nCell volume in second file: " << cellVolume2
+                    << "\nThe absolute deviation is " << dev.abs << ", and the tolerance limit is " << absTolerance << "."
+                    << "\nThe relative deviation is " << dev.rel << ", and the tolerance limit is " << relTolerance << "."
+                    << "\nCell 1 active: " << active1
+                    << "\nCell 2 active: " << active2);
+        }
+    }
+}
+
+
+
+void ECLRegressionTest::results() {
+    if (!this->acceptExtraKeywords) {
+        if (keywords1.size() != keywords2.size()) {
+            std::set<std::string> keys(keywords1.begin() , keywords1.end());
+            for (const auto& key2: keywords2)
+                keys.insert( key2 );
+
+            for (const auto& key : keys)
+                fprintf(stderr," %8s:%3d     %8s:%3d \n",key.c_str() , ecl_file_get_num_named_kw( ecl_file1 , key.c_str()),
+                                                         key.c_str() , ecl_file_get_num_named_kw( ecl_file2 , key.c_str()));
+
+
+            OPM_THROW(std::runtime_error, "\nKeywords in first file: " << keywords1.size()
+                      << "\nKeywords in second file: " << keywords2.size()
+                      << "\nThe number of keywords differ.");
+        }
+    }
+
+    for (const auto& it : keywords1)
+        resultsForKeyword(it);
+
+    if (analysis) {
+        std::cout << deviations.size() << " keyword"
+                  << (deviations.size() > 1 ? "s":"") << " exhibit failures" << std::endl;
+        for (const auto& iter : deviations) {
+            std::cout << "\t" << iter.first << std::endl;
+            std::cout << "\t\tFails for " << iter.second.size() << " entries" << std::endl;
+            std::cout.precision(7);
+            double absErr = std::max_element(iter.second.begin(), iter.second.end(),
+                                          [](const Deviation& a, const Deviation& b)
+                                          {
+                                            return a.abs < b.abs;
+                                          })->abs;
+            double relErr = std::max_element(iter.second.begin(), iter.second.end(),
+                                          [](const Deviation& a, const Deviation& b)
+                                          {
+                                            return a.rel < b.rel;
+                                          })->rel;
+            std::cout << "\t\tLargest absolute error: "
+                      <<  std::scientific << absErr << std::endl;
+            std::cout << "\t\tLargest relative error: "
+                      <<  std::scientific << relErr << std::endl;
+        }
+    }
+}
+
+
+
+void ECLRegressionTest::resultsForKeyword(const std::string& keyword) {
+    keywordValidForComparing(keyword);
+    const unsigned int occurrences1 = ecl_file_get_num_named_kw(ecl_file1, keyword.c_str());
+    const unsigned int occurrences2 = ecl_file_get_num_named_kw(ecl_file2, keyword.c_str());
+    if (!onlyLastOccurrence && occurrences1 != occurrences2) {
+        OPM_THROW(std::runtime_error, "For keyword " << keyword << ":"
+                << "\nKeyword occurrences in first file: "  << occurrences1
+                << "\nKeyword occurrences in second file: " << occurrences2
+                << "\nThe number of occurrences differ.");
+    }
+    // Assuming keyword type is constant for every occurrence:
+    const ecl_type_enum kw_type = ecl_type_get_type( ecl_file_iget_named_data_type(ecl_file1, keyword.c_str(), 0) );
+    switch(kw_type) {
+        case ECL_DOUBLE_TYPE:
+        case ECL_FLOAT_TYPE:
+            std::cout << "Comparing " << keyword << "...";
+            if (onlyLastOccurrence) {
+                doubleComparisonForOccurrence(keyword, occurrences1 - 1, occurrences2 - 1);
+            }
+            else {
+                for (unsigned int occurrence = 0; occurrence < occurrences1; ++occurrence) {
+                    doubleComparisonForOccurrence(keyword, occurrence, occurrence);
+                }
+            }
+            std::cout << "done." << std::endl;
+            printResultsForKeyword(keyword);
+            absDeviation.clear();
+            relDeviation.clear();
+            return;
+        case ECL_INT_TYPE:
+            std::cout << "Comparing " << keyword << "...";
+            if (onlyLastOccurrence) {
+                intComparisonForOccurrence(keyword, occurrences1 - 1, occurrences2 - 1);
+            }
+            else {
+                for (unsigned int occurrence = 0; occurrence < occurrences1; ++occurrence) {
+                    intComparisonForOccurrence(keyword, occurrence, occurrence);
+                }
+            }
+            break;
+        case ECL_CHAR_TYPE:
+            std::cout << "Comparing " << keyword << "...";
+            if (onlyLastOccurrence) {
+                charComparisonForOccurrence(keyword, occurrences1 - 1, occurrences2 - 1);
+            }
+            else {
+                for (unsigned int occurrence = 0; occurrence < occurrences1; ++occurrence) {
+                    charComparisonForOccurrence(keyword, occurrence, occurrence);
+                }
+            }
+            break;
+        case ECL_BOOL_TYPE:
+            std::cout << "Comparing " << keyword << "...";
+            if (onlyLastOccurrence) {
+                boolComparisonForOccurrence(keyword, occurrences1 - 1, occurrences2 - 1);
+            }
+            else {
+                for (unsigned int occurrence = 0; occurrence < occurrences1; ++occurrence) {
+                    boolComparisonForOccurrence(keyword, occurrence, occurrence);
+                }
+            }
+            break;
+        case ECL_MESS_TYPE:
+            std::cout << "\nKeyword " << keyword << " is of type MESS"
+                << ", which is not supported in regression test." << "\n\n";
+            return;
+        default:
+            std::cout << "\nKeyword " << keyword << "has undefined type." << std::endl;
+            return;
+    }
+    std::cout << "done." << std::endl;
+}

examples/test_util/EclRegressionTest.hpp

@@ -0,0 +1,93 @@
+/*
+   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/>.
+   */
+
+#ifndef ECLREGRESSIONTEST_HPP
+#define ECLREGRESSIONTEST_HPP
+
+#include "EclFilesComparator.hpp"
+
+/*! \brief A class for executing a regression test for two ECLIPSE files.
+    \details This class inherits from ECLFilesComparator, which opens and
+             closes the input cases and stores keywordnames.
+             The three public functions gridCompare(), results() and
+             resultsForKeyword() can be invoked to compare griddata
+             or keyworddata for all keywords or a given keyword (resultsForKeyword()).
+ */
+
+class ECLRegressionTest: public ECLFilesComparator {
+    private:
+        // These vectors store absolute and relative deviations, respecively. Note that they are whiped clean for every new keyword comparison.
+        std::vector<double> absDeviation, relDeviation;
+        // Keywords which should not contain negative values, i.e. uses allowNegativeValues = false in deviationsForCell():
+        const std::vector<std::string> keywordDisallowNegatives = {"SGAS", "SWAT", "PRESSURE"};
+
+        // Only compare last occurrence
+        bool onlyLastOccurrence = false;
+
+        // Accept extra keywords in the restart file of the 'new' simulation.
+        bool acceptExtraKeywords = false;
+
+
+        // Prints results stored in absDeviation and relDeviation.
+        void printResultsForKeyword(const std::string& keyword) const;
+
+        // Function which compares data at specific occurrences and for a specific keyword type. The functions takes two occurrence inputs to also be able to
+        // compare keywords which are shifted relative to each other in the two files. This is for instance handy when running flow with restart from different timesteps,
+        // and comparing the last timestep from the two runs.
+        void boolComparisonForOccurrence(const std::string& keyword, int occurrence1, int occurrence2) const;
+        void charComparisonForOccurrence(const std::string& keyword, int occurrence1, int occurrence2) const;
+        void intComparisonForOccurrence(const std::string& keyword, int occurrence1, int occurrence2) const;
+        void doubleComparisonForOccurrence(const std::string& keyword, int occurrence1, int occurrence2);
+        // deviationsForCell throws an exception if both the absolute deviation AND the relative deviation
+        // are larger than absTolerance and relTolerance, respectively. In addition,
+        // if allowNegativeValues is passed as false, an exception will be thrown when the absolute value
+        // of a negative value exceeds absTolerance. If no exceptions are thrown, the absolute and relative deviations are added to absDeviation and relDeviation.
+        void deviationsForCell(double val1, double val2, const std::string& keyword, int occurrence1, int occurrence2, size_t kw_size, size_t cell, bool allowNegativeValues = true);
+    public:
+        //! \brief Sets up the regression test.
+        //! \param[in] file_type Specifies which filetype to be compared, possible inputs are UNRSTFILE, INITFILE and RFTFILE.
+        //! \param[in] basename1 Full path without file extension to the first case.
+        //! \param[in] basename2 Full path without file extension to the second case.
+        //! \param[in] absTolerance Tolerance for absolute deviation.
+        //! \param[in] relTolerance Tolerance for relative deviation.
+        //! \details This constructor only calls the constructor of the superclass, see the docs for ECLFilesComparator for more information.
+        ECLRegressionTest(int file_type, const std::string& basename1, const std::string& basename2, double absTolerance, double relTolerance):
+            ECLFilesComparator(file_type, basename1, basename2, absTolerance, relTolerance) {}
+
+        //! \brief Option to only compare last occurrence
+        void setOnlyLastOccurrence(bool onlyLastOccurrenceArg) {this->onlyLastOccurrence = onlyLastOccurrenceArg;}
+
+        // Accept extra keywords: If this switch is set to true the comparison
+        // of restart files will ignore extra keywords which are only present
+        // in the new simulation.
+        void setAcceptExtraKeywords(bool acceptExtraKeywordsArg) { this->acceptExtraKeywords = acceptExtraKeywordsArg; }
+
+        //! \brief Compares grid properties of the two cases.
+        // gridCompare() checks if both the number of active and global cells in the two cases are the same. If they are, and volumecheck is true, all cells are looped over to calculate the cell volume deviation for the two cases. If the both the relative and absolute deviation exceeds the tolerances, an exception is thrown.
+        void gridCompare(const bool volumecheck) const;
+        //! \brief Calculates deviations for all keywords.
+        // This function checks if the number of keywords of the two cases are equal, and if it is, resultsForKeyword() is called for every keyword. If not, an exception is thrown.
+        void results();
+        //! \brief Calculates deviations for a specific keyword.
+        //! \param[in] keyword Keyword which should be compared, if this keyword is absent in one of the cases, an exception will be thrown.
+        //! \details This function loops through every report step and every cell and compares the values for the given keyword from the two input cases. If the absolute or relative deviation between the two values for each step exceeds both the absolute tolerance and the relative tolerance (stored in ECLFilesComparator), an exception is thrown. In addition, some keywords are marked for "disallow negative values" -- these are SGAS, SWAT and PRESSURE. An exception is thrown if a value of one of these keywords is both negative and has an absolute value larger than the absolute tolerance. If no exceptions are thrown, resultsForKeyword() uses the private member funtion printResultsForKeyword to print the average and median deviations.
+        void resultsForKeyword(const std::string& keyword);
+};
+
+#endif

examples/test_util/compareECL.cpp

@@ -16,7 +16,11 @@
    along with OPM.  If not, see <http://www.gnu.org/licenses/>.
    */
 
-#include <opm/test_util/EclFilesComparator.hpp>
+#include "EclIntegrationTest.hpp"
+#include "EclRegressionTest.hpp"
+#include "summaryIntegrationTest.hpp"
+#include "summaryRegressionTest.hpp"
+
 #include <opm/common/ErrorMacros.hpp>
 
 #include <ert/util/util.h>
@@ -29,7 +33,7 @@
 #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"
+    std::cout << "\ncompareECL compares ECLIPSE files (restart (.RST), unified restart (.UNRST), initial (.INIT), summary (.SMRY), unified summary (.UNSMRY) 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"
@@ -37,25 +41,32 @@ static void printHelp() {
         << "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"
         << "-a Run a full analysis of errors.\n"
+        << "-g Will print the vector with the greatest error ratio.\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"
+        << "-K Will not allow different amount of keywords in the two files. Throws an exception if the amount are different.\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"
+        << "-m mainVar. Will calculate the error ratio for one main variable. Valid input is WOPR, WWPR, WGPR or WBHP.\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"
+        << "-R Will allow comparison between a restarted simulation and a normal simulation for summary regression tests. The files must end at the same time.\n"
+        << "-s int Sets the number of spikes that are allowed for each keyword in summary integration tests.\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 SMRY  \t Compare two cases consistent of (unified) summary files.\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"
+        << "-v For the rate keywords WOPR, WGPR, WWPR and WBHP. Calculates the error volume of the two summary files. This is printed to screen.\n"
+        << "\nExample 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"
@@ -108,24 +119,37 @@ int main(int argc, char** argv) {
     ecl_file_enum file_type      = ECL_UNIFIED_RESTART_FILE;
     // RegressionTest is default
     bool integrationTest         = false;
+    bool allowDifferentAmount    = true;
     bool checkNumKeywords        = false;
+    bool findGreatestErrorRatio  = false;
+    bool findVolumeError         = false;
     bool onlyLastOccurrence      = false;
     bool printKeywords           = false;
     bool printKeywordsDifference = false;
+    bool restartFile             = false;
     bool specificKeyword         = false;
     bool specificFileType        = false;
+    bool allowSpikes             = false;
     bool throwOnError            = true;
+    bool throwTooGreatErrorRatio = true;
+    bool acceptExtraKeywords     = false;
     bool analysis                = false;
     bool volumecheck             = true;
     char* keyword                = nullptr;
     char* fileTypeCstr           = nullptr;
+    const char* mainVariable     = nullptr;
     int c                        = 0;
+    int spikeLimit               = -1;
 
-    while ((c = getopt(argc, argv, "hiIk:alnpPt:V")) != -1) {
+    while ((c = getopt(argc, argv, "hiIk:alnpPt:VRgs:m:vKx")) != -1) {
         switch (c) {
             case 'a':
               analysis = true;
               break;
+            case 'g':
+                findGreatestErrorRatio = true;
+                throwTooGreatErrorRatio = false;
+                break;
             case 'h':
                 printHelp();
                 return 0;
@@ -136,32 +160,51 @@ int main(int argc, char** argv) {
                 integrationTest = true;
                 checkNumKeywords = true;
                 break;
-            case 'n':
-                throwOnError = false;
-                break;
             case 'k':
                 specificKeyword = true;
                 keyword = optarg;
                 break;
+            case 'K':
+                allowDifferentAmount = false;
+                break;
             case 'l':
                 onlyLastOccurrence = true;
                 break;
+            case 'm':
+                mainVariable = optarg;
+                break;
+            case 'n':
+                throwOnError = false;
+                break;
             case 'p':
                 printKeywords = true;
                 break;
             case 'P':
                 printKeywordsDifference = true;
                 break;
+            case 'R':
+                restartFile = true;
+                break;
+            case 's':
+                allowSpikes = true;
+                spikeLimit = atof(optarg);
+                break;
             case 't':
                 specificFileType = true;
                 fileTypeCstr = optarg;
                 break;
+            case 'v':
+                findVolumeError = true;
+                break;
             case 'V':
                 volumecheck = false;
                 break;
+            case 'x':
+                acceptExtraKeywords = true;
+                break;
             case '?':
-                if (optopt == 'k') {
-                    std::cerr << "Option k requires a keyword as argument, see manual (-h) for more information." << std::endl;
+                if (optopt == 'k' || optopt == 'm' || optopt == 's') {
+                    std::cerr << "Option " << optopt << " requires a keyword as argument, see manual (-h) for more information." << std::endl;
                     return EXIT_FAILURE;
                 }
                 else if (optopt == 't') {
@@ -190,6 +233,7 @@ int main(int argc, char** argv) {
             << "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);
@@ -215,15 +259,68 @@ int main(int argc, char** argv) {
         else if (fileTypeString == "RFT") {
             file_type = ECL_RFT_FILE;
         }
+        else if (fileTypeString == "SMRY")
+            file_type = ECL_SUMMARY_FILE;
         else {
             std::cerr << "Unknown ECLIPSE filetype specified with option -t. Please run compareECL -h to see manual." << std::endl;
             return EXIT_FAILURE;
         }
     }
+
+    if (restartFile && (file_type != ECL_SUMMARY_FILE || integrationTest)) {
+        std::cerr << "Error: -R can only be used in for summary regression tests." << std::endl;
+        return EXIT_FAILURE;
+    }
+
     std::cout << "Comparing '" << basename1 << "' to '" << basename2 << "'." << std::endl;
     try {
-        if (integrationTest) {
-            IntegrationTest comparator(basename1, basename2, absTolerance, relTolerance);
+        if (file_type == ECL_SUMMARY_FILE) {
+            if(!integrationTest){
+                SummaryRegressionTest compare(basename1,basename2,absTolerance,relTolerance);
+                compare.throwOnErrors(throwOnError);
+                compare.doAnalysis(analysis);
+                compare.setPrintKeywords(printKeywords);
+                compare.setIsRestartFile(restartFile);
+                compare.setAllowDifferentNumberOfKeywords(acceptExtraKeywords);
+                if(specificKeyword){
+                    compare.getRegressionTest(keyword);
+                }
+                else{
+                    compare.setPrintKeywords(printKeywords);
+                    compare.getRegressionTest();
+                }
+            } else {
+                SummaryIntegrationTest compare(basename1,basename2,absTolerance,relTolerance);
+                compare.throwOnErrors(throwOnError);
+                compare.setFindVectorWithGreatestErrorRatio(findGreatestErrorRatio);
+                compare.setAllowSpikes(allowSpikes);
+                if (mainVariable) {
+                    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.");
+                    }
+                }
+                compare.setFindVolumeError(findVolumeError);
+                if (spikeLimit != -1) {
+                    compare.setSpikeLimit(spikeLimit);
+                }
+                compare.setAllowDifferentAmountOfKeywords(allowDifferentAmount);
+                compare.setPrintKeywords(printKeywords);
+                compare.setThrowExceptionForTooGreatErrorRatio(throwTooGreatErrorRatio);
+                if(specificKeyword){
+                    compare.setPrintSpecificKeyword(specificKeyword);
+                    compare.getIntegrationTest(keyword);
+                    return 0;
+                }
+                compare.getIntegrationTest();
+            }
+        }
+        else if (integrationTest) {
+            ECLIntegrationTest comparator(basename1, basename2, absTolerance, relTolerance);
             if (printKeywords) {
                 comparator.printKeywords();
                 return 0;
@@ -249,9 +346,10 @@ int main(int argc, char** argv) {
             }
         }
         else {
-            RegressionTest comparator(file_type, basename1, basename2, absTolerance, relTolerance);
+            ECLRegressionTest comparator(file_type, basename1, basename2, absTolerance, relTolerance);
             comparator.throwOnErrors(throwOnError);
             comparator.doAnalysis(analysis);
+            comparator.setAcceptExtraKeywords(acceptExtraKeywords);
             if (printKeywords) {
                 comparator.printKeywords();
                 return 0;

examples/test_util/compareSummary.cpp

@@ -1,229 +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 << "-a \tRun a full analysis of errors." << 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;
-    bool analysis = false;
-    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:napP:rRs:vV:")) != -1) {
-        switch (c) {
-            case 'a':
-                analysis = true;
-                break;
-            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);
-            compare.doAnalysis(analysis);
-            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;
-}

examples/test_util/summaryComparator.cpp

@@ -16,18 +16,20 @@
    along with OPM.  If not, see <http://www.gnu.org/licenses/>.
    */
 
-#include <opm/test_util/summaryComparator.hpp>
-#include <ert/ecl/ecl_sum.h>
-#include <ert/util/stringlist.h>
-#include <ert/util/int_vector.h>
-#include <ert/util/bool_vector.h>
+#include "summaryComparator.hpp"
+#include <ert/ecl/ecl_sum.hpp>
+#include <ert/util/stringlist.hpp>
+#include <ert/util/int_vector.hpp>
+#include <ert/util/bool_vector.hpp>
 #include <opm/common/ErrorMacros.hpp>
 #include <cmath>
 #include <numeric>
 
-SummaryComparator::SummaryComparator(const char* basename1, const char* basename2, double absoluteTol, double relativeTol){
-    ecl_sum1 = ecl_sum_fread_alloc_case(basename1, ":");
-    ecl_sum2 = ecl_sum_fread_alloc_case(basename2, ":");
+SummaryComparator::SummaryComparator(const std::string& basename1,
+                                     const std::string& basename2,
+                                     double absoluteTol, double relativeTol){
+    ecl_sum1 = ecl_sum_fread_alloc_case(basename1.c_str(), ":");
+    ecl_sum2 = ecl_sum_fread_alloc_case(basename2.c_str(), ":");
     if (ecl_sum1 == nullptr || ecl_sum2 == nullptr) {
         OPM_THROW(std::runtime_error, "Not able to open files");
     }

examples/test_util/summaryComparator.hpp

@@ -20,6 +20,7 @@
 #ifndef SUMMARYCOMPARATOR_HPP
 #define SUMMARYCOMPARATOR_HPP
 
+#include "Deviation.hpp"
 #include <iostream>
 #include <iomanip>
 #include <map>
@@ -47,13 +48,6 @@ struct ecl_sum_struct;
 typedef struct ecl_sum_struct ecl_sum_type;
 
 
-//! \brief Struct for storing the deviation between two values.
-struct Deviation {
-    double abs = 0;     //!< The absolute deviation
-    double rel = 0;     //!< The relative deviation
-};
-
-
 class SummaryComparator {
     private:
         double absoluteTolerance = 0; //!< The maximum absolute deviation that is allowed between two values.
@@ -145,7 +139,9 @@ class SummaryComparator {
         //! \param[in] absoluteTolerance The absolute tolerance which is to be used in the test.
         //! \param[in] relativeTolerance The relative tolerance which is to be used in the test.
         //! \details The constructor creates an object of the class, and openes the files, an exception is thrown if the opening of the files fails. \n It creates stringlists, in which keywords are to be stored, and figures out which keylist that contains the more/less keywords. \n Also the private member variables aboluteTolerance and relativeTolerance are set.
-        SummaryComparator(const char* basename1, const char* basename2, double absoluteTolerance, double relativeTolerance);
+        SummaryComparator(const std::string& basename1,
+                          const std::string& basename2,
+                          double absoluteTolerance, double relativeTolerance);
 
         //! \brief Destructor
         //! \details The destructor takes care of the allocated memory in which data has been stored.

examples/test_util/summaryIntegrationTest.cpp

@@ -17,14 +17,14 @@
    */
 
 
-#include <opm/test_util/summaryIntegrationTest.hpp>
+#include "summaryIntegrationTest.hpp"
 #include <opm/common/ErrorMacros.hpp>
-#include <ert/ecl/ecl_sum.h>
-#include <ert/util/stringlist.h>
+#include <ert/ecl/ecl_sum.hpp>
+#include <ert/util/stringlist.hpp>
 #include <cmath>
 
 
-void IntegrationTest::getIntegrationTest(){
+void SummaryIntegrationTest::getIntegrationTest(){
     std::vector<double> timeVec1, timeVec2;
     setTimeVecs(timeVec1, timeVec2);  // Sets the time vectors, they are equal for all keywords (WPOR:PROD01 etc)
     setDataSets(timeVec1, timeVec2);
@@ -89,7 +89,7 @@ void IntegrationTest::getIntegrationTest(){
 }
 
 
-void IntegrationTest::getIntegrationTest(const char* keyword){
+void SummaryIntegrationTest::getIntegrationTest(const char* keyword){
     if(stringlist_contains(keysShort,keyword) && stringlist_contains(keysLong, keyword)){
         std::vector<double> timeVec1, timeVec2;
         setTimeVecs(timeVec1, timeVec2);  // Sets the time vectors, they are equal for all keywords (WPOR:PROD01 etc)
@@ -115,9 +115,9 @@ void IntegrationTest::getIntegrationTest(const char* keyword){
 }
 
 
-void IntegrationTest::checkForKeyword(const std::vector<double>& timeVec1,
-                                      const std::vector<double>& timeVec2,
-                                      const char* keyword){
+void SummaryIntegrationTest::checkForKeyword(const std::vector<double>& timeVec1,
+                                             const std::vector<double>& timeVec2,
+                                             const char* keyword){
     std::vector<double> dataVec1, dataVec2;
     getDataVecs(dataVec1,dataVec2,keyword);
     chooseReference(timeVec1, timeVec2,dataVec1,dataVec2);
@@ -130,7 +130,7 @@ void IntegrationTest::checkForKeyword(const std::vector<double>& timeVec1,
 }
 
 
-int IntegrationTest::checkDeviation(const Deviation& deviation){
+int SummaryIntegrationTest::checkDeviation(const Deviation& deviation){
     double absTol = getAbsTolerance();
     double relTol = getRelTolerance();
     if (deviation.rel> relTol && deviation.abs > absTol){
@@ -140,10 +140,10 @@ int IntegrationTest::checkDeviation(const Deviation& deviation){
 }
 
 
-void IntegrationTest::findGreatestErrorRatio(const WellProductionVolume& volume,
-                                             double &greatestRatio,
-                                             const char* currentKeyword,
-                                             std::string &greatestErrorRatio){
+void SummaryIntegrationTest::findGreatestErrorRatio(const WellProductionVolume& volume,
+                                                    double &greatestRatio,
+                                                    const char* currentKeyword,
+                                                    std::string &greatestErrorRatio){
     if (volume.total != 0 && (volume.total - volume.error > getAbsTolerance()) ){
         if(volume.error/volume.total > greatestRatio){
             greatestRatio = volume.error/volume.total;
@@ -154,14 +154,11 @@ void IntegrationTest::findGreatestErrorRatio(const WellProductionVolume& volume,
 }
 
 
-void IntegrationTest::volumeErrorCheck(const char* keyword){
-    const smspec_node_type * node = ecl_sum_get_general_var_node (ecl_sum_fileShort ,keyword);//doesn't matter which ecl_sum_file one uses, the kewyord SHOULD be equal in terms of smspec data.
-    bool hist = smspec_node_is_historical(node);
-    /* returns true if the keyword corresponds to a summary vector "history".
-       E.g. WOPRH, where the last character, 'H', indicates that it is a HISTORY vector.*/
-    if(hist){
-        return;//To make sure we do not include history vectors.
-    }
+void SummaryIntegrationTest::volumeErrorCheck(const char* keyword){
+    const ecl::smspec_node * node = ecl_sum_get_general_var_node (ecl_sum_fileShort ,keyword);//doesn't matter which ecl_sum_file one uses, the kewyord SHOULD be equal in terms of smspec data.
+    if (node->is_historical())
+        return;
+
     if (!mainVariable.empty()){
         std::string keywordString(keyword);
         std::string firstFour = keywordString.substr(0,4);
@@ -199,7 +196,7 @@ void IntegrationTest::volumeErrorCheck(const char* keyword){
 }
 
 
-void IntegrationTest::updateVolumeError(const char* keyword){
+void SummaryIntegrationTest::updateVolumeError(const char* keyword){
     std::string keywordString(keyword);
     std::string firstFour = keywordString.substr(0,4);
 
@@ -223,7 +220,7 @@ void IntegrationTest::updateVolumeError(const char* keyword){
 }
 
 
-WellProductionVolume IntegrationTest::getWellProductionVolume(const char * keyword){
+WellProductionVolume SummaryIntegrationTest::getWellProductionVolume(const char * keyword){
     double total = integrate(*referenceVec, *referenceDataVec);
     double error = integrateError(*referenceVec, *referenceDataVec,
                                   *checkVec, *checkDataVec);
@@ -239,7 +236,7 @@ WellProductionVolume IntegrationTest::getWellProductionVolume(const char * keywo
 }
 
 
-void IntegrationTest::evaluateWellProductionVolume(){
+void SummaryIntegrationTest::evaluateWellProductionVolume(){
     if(mainVariable.empty()){
         double ratioWOP, ratioWWP, ratioWGP, ratioWBHP;
         ratioWOP = WOP.error/WOP.total;
@@ -266,7 +263,7 @@ void IntegrationTest::evaluateWellProductionVolume(){
 }
 
 
-void IntegrationTest::checkWithSpikes(const char* keyword){
+void SummaryIntegrationTest::checkWithSpikes(const char* keyword){
     int errorOccurrences = 0;
     size_t jvar = 0 ;
     bool spikeCurrent = false;
@@ -295,9 +292,9 @@ void IntegrationTest::checkWithSpikes(const char* keyword){
 
 
 WellProductionVolume
-IntegrationTest::getSpecificWellVolume(const std::vector<double>& timeVec1,
-                                       const std::vector<double>& timeVec2,
-                                       const char* keyword){
+SummaryIntegrationTest::getSpecificWellVolume(const std::vector<double>& timeVec1,
+                                              const std::vector<double>& timeVec2,
+                                              const char* keyword){
     std::vector<double> dataVec1, dataVec2;
     getDataVecs(dataVec1,dataVec2,keyword);
     chooseReference(timeVec1, timeVec2,dataVec1,dataVec2);
@@ -305,20 +302,8 @@ IntegrationTest::getSpecificWellVolume(const std::vector<double>& timeVec1,
 }
 
 
-#if 0
-bool IntegrationTest::checkUnits(const char * keyword){
-    const smspec_node_type * node1 = ecl_sum_get_general_var_node (ecl_sum_fileShort ,keyword);
-    const smspec_node_type * node2 = ecl_sum_get_general_var_node (ecl_sum_fileLong ,keyword);
-    if(strcmp(smspec_node_get_unit(node1),smspec_node_get_unit(node2)) == 0){
-        return true;
-    }
-    return false;
-}
-#endif
-
-
-double IntegrationTest::integrate(const std::vector<double>& timeVec,
-                                  const std::vector<double>& dataVec){
+double SummaryIntegrationTest::integrate(const std::vector<double>& timeVec,
+                                         const std::vector<double>& dataVec){
     double totalSum = 0;
     if(timeVec.size() != dataVec.size()){
         OPM_THROW(std::runtime_error, "The size of the time vector does not match the size of the data vector.");
@@ -332,10 +317,10 @@ double IntegrationTest::integrate(const std::vector<double>& timeVec,
 }
 
 
-double IntegrationTest::integrateError(const std::vector<double>& timeVec1,
-                                       const std::vector<double>& dataVec1,
-                                       const std::vector<double>& timeVec2,
-                                       const std::vector<double>& dataVec2){
+double SummaryIntegrationTest::integrateError(const std::vector<double>& timeVec1,
+                                              const std::vector<double>& dataVec1,
+                                              const std::vector<double>& timeVec2,
+                                              const std::vector<double>& dataVec2){
     // When the data corresponds to a rate the integration will become a Riemann
     // sum.  This function calculates the Riemann sum of the error.  The reason why
     // a Riemann sum is used is because of the way the data is written to file.

examples/test_util/summaryIntegrationTest.hpp

@@ -17,7 +17,7 @@
    along with OPM.  If not, see <http://www.gnu.org/licenses/>.
    */
 
-#include <opm/test_util/summaryComparator.hpp>
+#include "summaryComparator.hpp"
 
 //! \brief Struct for storing the total area under a graph.
 //! \details Used when plotting summary vector against time. In most cases this represents a volume.
@@ -35,7 +35,7 @@ struct WellProductionVolume{
 };
 
 //! \details The class inherits from the SummaryComparator class, which takes care of all file reading. \n The IntegrationTest class compares values from the two different files and throws exceptions when the deviation is unsatisfying.
-class IntegrationTest: public SummaryComparator {
+class SummaryIntegrationTest: public SummaryComparator {
     private:
         bool allowSpikes = false; //!< Boolean value, when true checkForSpikes is included as a sub test in the integration test. By default: false.
         bool findVolumeError = false; //!< Boolean value, when true volumeErrorCheck() is included as a sub test in the integration test. By default: false.
@@ -124,8 +124,9 @@ class IntegrationTest: public SummaryComparator {
         //! \param[in] atol The absolute tolerance which is to be used in the test.
         //! \param[in] rtol The relative tolerance which is to be used in the test.
         //! \details The constructor calls the constructor of the super class.
-        IntegrationTest(const char* basename1, const char* basename2,
-                        double atol, double rtol) :
+        SummaryIntegrationTest(const std::string& basename1,
+                               const std::string& basename2,
+                               double atol, double rtol) :
             SummaryComparator(basename1, basename2,  atol, rtol) {}
 
         //! \brief This function sets the private member variable allowSpikes.

examples/test_util/summaryRegressionTest.cpp

@@ -16,19 +16,21 @@
    along with OPM.  If not, see <http://www.gnu.org/licenses/>.
    */
 
-#include <opm/test_util/summaryRegressionTest.hpp>
+#include "summaryRegressionTest.hpp"
 #include <opm/common/ErrorMacros.hpp>
-#include <ert/ecl/ecl_sum.h>
+#include <ert/ecl/ecl_sum.hpp>
 #include <ert/util/stringlist.h>
 #include <string>
 
-void RegressionTest::getRegressionTest(){
+void SummaryRegressionTest::getRegressionTest(){
     std::vector<double> timeVec1, timeVec2;
     setTimeVecs(timeVec1, timeVec2);  // Sets the time vectors, they are equal for all keywords (WPOR:PROD01 etc)
     setDataSets(timeVec1, timeVec2); //Figures which dataset that contains more/less values pr keyword vector.
     std::cout << "Comparing " << timeVec1.size() << " steps." << std::endl;
     int ivar = 0;
-    if(stringlist_get_size(keysShort) != stringlist_get_size(keysLong)){
+    if((! this->allowDifferentNumberOfKeywords) &&
+        (stringlist_get_size(keysShort) != stringlist_get_size(keysLong)))
+    {
         int missing_count = 0;
         std::cout << "Keywords missing from one case: " << std::endl;
 
@@ -98,13 +100,13 @@ void RegressionTest::getRegressionTest(){
     }
     if (throwAtEnd)
       OPM_THROW(std::runtime_error, "Regression test failed.");
-    else
+    else if (deviations.empty())
       std::cout << "Regression test succeeded." << std::endl;
 }
 
 
 
-void RegressionTest::getRegressionTest(const char* keyword){
+void SummaryRegressionTest::getRegressionTest(const char* keyword){
     std::vector<double> timeVec1, timeVec2;
     setTimeVecs(timeVec1, timeVec2);  // Sets the time vectors, they are equal for all keywords (WPOR:PROD01 etc)
     setDataSets(timeVec1, timeVec2); //Figures which dataset that contains more/less values pr keyword vector.
@@ -126,7 +128,7 @@ void RegressionTest::getRegressionTest(const char* keyword){
 
 
 
-bool RegressionTest::checkDeviation(Deviation deviation, const char* keyword, int refIndex, int checkIndex){
+bool SummaryRegressionTest::checkDeviation(Deviation deviation, const char* keyword, int refIndex, int checkIndex){
     double absTol = getAbsTolerance();
     double relTol = getRelTolerance();
 
@@ -149,7 +151,7 @@ bool RegressionTest::checkDeviation(Deviation deviation, const char* keyword, in
 
 
 
-bool RegressionTest::checkForKeyword(std::vector<double>& timeVec1, std::vector<double>& timeVec2, const char* keyword){
+bool SummaryRegressionTest::checkForKeyword(std::vector<double>& timeVec1, std::vector<double>& timeVec2, const char* keyword){
     std::vector<double> dataVec1, dataVec2;
     getDataVecs(dataVec1,dataVec2,keyword);
     chooseReference(timeVec1, timeVec2,dataVec1,dataVec2);
@@ -158,7 +160,7 @@ bool RegressionTest::checkForKeyword(std::vector<double>& timeVec1, std::vector<
 
 
 
-bool RegressionTest::startTest(const char* keyword){
+bool SummaryRegressionTest::startTest(const char* keyword){
     size_t jvar = 0;
     Deviation deviation;
     bool result = true;
@@ -169,3 +171,8 @@ bool RegressionTest::startTest(const char* keyword){
 
     return result;
 }
+
+void SummaryRegressionTest::setAllowDifferentNumberOfKeywords(const bool allow)
+{
+    this->allowDifferentNumberOfKeywords = allow;
+}

examples/test_util/summaryRegressionTest.hpp

@@ -20,10 +20,10 @@
 #ifndef SUMMARYREGRESSIONTEST_HPP
 #define SUMMARYREGRESSIONTEST_HPP
 
-#include <opm/test_util/summaryComparator.hpp>
+#include "summaryComparator.hpp"
 
 //! \details  The class inherits from the SummaryComparator class, which takes care of all file reading. \n The RegressionTest class compares the values from the two different files and throws exceptions when the deviation is unsatisfying.
-class RegressionTest: public SummaryComparator {
+class SummaryRegressionTest: public SummaryComparator {
     private:
         //! \brief Gathers the correct data for comparison for a specific keyword
         //! \param[in] timeVec1 The time steps of file 1.
@@ -48,6 +48,12 @@ class RegressionTest: public SummaryComparator {
         bool checkDeviation(Deviation deviation, const char* keyword, int refIndex, int checkIndex);
 
         bool isRestartFile = false; //!< Private member variable, when true the files that are being compared is a restart file vs a normal file
+
+        /// Whether or not to require that the two files have the same
+        /// number of keywords.  Throw exception if not.
+        /// Default value: false (don't allow different number of keywords).
+        bool allowDifferentNumberOfKeywords = false;
+
     public:
         //! \brief Constructor, creates an object of RefressionTest class.
         //! \param[in] basename1 Path to file1 without extension.
@@ -55,7 +61,9 @@ class RegressionTest: public SummaryComparator {
         //! \param[in] relativeTol The relative tolerance which is to be used in the test.
         //! \param[in] absoluteTol The absolute tolerance which is to be used in the test.
         //! \details The constructor calls the constructor of the super class.
-        RegressionTest(const char* basename1, const char* basename2, double relativeTol, double absoluteTol):
+        SummaryRegressionTest(const std::string& basename1,
+                              const std::string& basename2,
+                              double relativeTol, double absoluteTol) :
             SummaryComparator(basename1, basename2, relativeTol, absoluteTol) {}
 
         //! \details The function executes a regression test for all the keywords. If the two files do not match in amount of keywords, an exception is thrown.
@@ -67,6 +75,13 @@ class RegressionTest: public SummaryComparator {
         //! \brief This function sets the private member variable isRestartFiles
         //! \param[in] boolean Boolean value
         void setIsRestartFile(bool boolean){this->isRestartFile = boolean;}
+
+        /// \brief Dynamically control whether or not to require equal
+        ///    number of keywords (vectors) in the two result sets.
+        ///
+        /// \param[in] allow Whether or not to allow different number of
+        ///    summary keywords in the two result sets.
+        void setAllowDifferentNumberOfKeywords(const bool allow);
 };
 
 #endif

jenkins/build-opm-module.sh

@@ -79,10 +79,26 @@ function printHeader {
 # $2 = 0 to build and install module, 1 to build and test module
 # $3 = Source root of module to build
 function build_module {
-  cmake $3 -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=$2 -DCMAKE_TOOLCHAIN_FILE=${configurations[$configuration]} $1
+  CMAKE_PARAMS="$1"
+  DO_TEST_FLAG="$2"
+  MOD_SRC_DIR="$3"
+  cmake "$MOD_SRC_DIR" -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=$DO_TEST_FLAG -DCMAKE_TOOLCHAIN_FILE=${configurations[$configuration]} $CMAKE_PARAMS
   test $? -eq 0 || exit 1
-  if test $2 -eq 1
+  if test $DO_TEST_FLAG -eq 1
   then
+
+    pushd "$CWD"
+    cd "$MOD_SRC_DIR"
+    if test -x "./jenkins/pre-build.sh"; then
+        echo "Running pre-build script"
+        if ! "./jenkins/pre-build.sh"; then
+            exit 1
+        fi
+    else
+        echo "No pre-build script detected"
+    fi
+    popd
+
     if [ ! -z $BUILDTHREADS ]
     then
       cmake --build . -- -j$BUILDTHREADS
@@ -112,6 +128,7 @@ function build_module {
     else
       cmake --build . --target install
     fi
+    test $? -eq 0 || exit 3
   fi
 }
 

msim/include/opm/msim/msim.hpp

@@ -0,0 +1,52 @@
+#ifndef ISIM_MAIN_HPP
+#define ISIM_MAIN_HPP
+
+#include <functional>
+#include <string>
+#include <map>
+
+#include <opm/parser/eclipse/Parser/ErrorGuard.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>
+
+#include <opm/output/data/Solution.hpp>
+#include <opm/output/data/Wells.hpp>
+
+
+namespace Opm {
+
+class EclipseIO;
+class ParseContext;
+class Parser;
+
+class msim {
+
+public:
+    using well_rate_function = double(const EclipseState&, const Schedule&, const data::Solution&, size_t report_step, double seconds_elapsed);
+    using solution_function = void(const EclipseState&, const Schedule&, data::Solution&, size_t report_step, double seconds_elapsed);
+
+    msim(const EclipseState& state);
+
+    void well_rate(const std::string& well, data::Rates::opt rate, std::function<well_rate_function> func);
+    void solution(const std::string& field, std::function<solution_function> func);
+    void run(Schedule& schedule, EclipseIO& io);
+    void post_step(Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, EclipseIO& io) const;
+private:
+
+    void run_step(const Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, EclipseIO& io) const;
+    void run_step(const Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, double dt, EclipseIO& io) const;
+    void output(size_t report_step, bool substep, double seconds_elapsed, const data::Solution& sol, const data::Wells& well_data, EclipseIO& io) const;
+    void simulate(const Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, double seconds_elapsed, double time_step) const;
+
+    EclipseState state;
+
+    std::map<std::string, std::map<data::Rates::opt, std::function<well_rate_function>>> well_rates;
+    std::map<std::string, std::function<solution_function>> solutions;
+};
+}
+
+
+#endif

msim/src/msim.cpp

@@ -0,0 +1,148 @@
+/*
+  Copyright 2018 Equinor 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/output/eclipse/EclipseIO.hpp>
+#include <opm/output/eclipse/RestartValue.hpp>
+#include <opm/output/data/Solution.hpp>
+#include <opm/output/data/Wells.hpp>
+
+#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.hpp>
+#include <opm/parser/eclipse/Parser/Parser.hpp>
+#include <opm/parser/eclipse/Parser/ParseContext.hpp>
+#include <opm/parser/eclipse/Parser/ErrorGuard.hpp>
+#include <opm/msim/msim.hpp>
+
+namespace Opm {
+
+msim::msim(const EclipseState& state) :
+    state(state)
+{}
+
+void msim::run(Schedule& schedule, EclipseIO& io) {
+    const double week = 7 * 86400;
+    data::Solution sol;
+    data::Wells well_data;
+
+    io.writeInitial();
+    for (size_t report_step = 1; report_step < schedule.size(); report_step++) {
+        double time_step = std::min(week, 0.5*schedule.stepLength(report_step - 1));
+        run_step(schedule, sol, well_data, report_step, time_step, io);
+        post_step(schedule, sol, well_data, report_step, io);
+    }
+}
+
+
+void msim::post_step(Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, EclipseIO& io) const {
+    const auto& actions = schedule.actions();
+    if (actions.empty())
+        return;
+
+    const SummaryState& summary_state = io.summaryState();
+    ActionContext context( summary_state );
+    std::vector<std::string> matching_wells;
+
+    auto sim_time = schedule.simTime(report_step);
+    for (const auto& action : actions.pending(sim_time)) {
+        if (action->eval(sim_time, context, matching_wells))
+            schedule.applyAction(report_step, *action, matching_wells);
+    }
+}
+
+
+
+void msim::run_step(const Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, EclipseIO& io) const {
+    this->run_step(schedule, sol, well_data, report_step, schedule.stepLength(report_step - 1), io);
+}
+
+
+void msim::run_step(const Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, double dt, EclipseIO& io) const {
+    double start_time = schedule.seconds(report_step - 1);
+    double end_time = schedule.seconds(report_step);
+    double seconds_elapsed = start_time;
+
+    while (seconds_elapsed < end_time) {
+        double time_step = dt;
+        if ((seconds_elapsed + time_step) > end_time)
+            time_step = end_time - seconds_elapsed;
+
+        this->simulate(schedule, sol, well_data, report_step, seconds_elapsed, time_step);
+
+        seconds_elapsed += time_step;
+        this->output(report_step,
+                     (seconds_elapsed < end_time),
+                     seconds_elapsed,
+                     sol,
+                     well_data,
+                     io);
+    }
+}
+
+
+
+void msim::output(size_t report_step, bool substep, double seconds_elapsed, const data::Solution& sol, const data::Wells& well_data, EclipseIO& io) const {
+    RestartValue value(sol, well_data);
+    io.writeTimeStep(report_step,
+                     false,
+                     seconds_elapsed,
+                     value,
+                     {},
+                     {},
+                     {});
+}
+
+
+void msim::simulate(const Schedule& schedule, data::Solution& sol, data::Wells& well_data, size_t report_step, double seconds_elapsed, double time_step) const {
+    for (const auto& sol_pair : this->solutions) {
+        auto func = sol_pair.second;
+        func(this->state, schedule, sol, report_step, seconds_elapsed + time_step);
+    }
+
+    for (const auto& well_pair : this->well_rates) {
+        const std::string& well_name = well_pair.first;
+        data::Well& well = well_data[well_name];
+        for (const auto& rate_pair : well_pair.second) {
+            auto rate = rate_pair.first;
+            auto func = rate_pair.second;
+
+            well.rates.set(rate, func(this->state, schedule, sol, report_step, seconds_elapsed + time_step));
+        }
+
+        // This is complete bogus; a temporary fix to pass an assert() in the
+        // the restart output.
+        well.connections.resize(100);
+    }
+}
+
+
+void msim::well_rate(const std::string& well, data::Rates::opt rate, std::function<well_rate_function> func) {
+    this->well_rates[well][rate] = func;
+}
+
+
+void msim::solution(const std::string& field, std::function<solution_function> func) {
+    this->solutions[field] = func;
+}
+
+
+}
+
+

opm/output/data/Wells.hpp

@@ -20,12 +20,14 @@
 #ifndef OPM_OUTPUT_WELLS_HPP
 #define OPM_OUTPUT_WELLS_HPP
 
+#include <algorithm>
+#include <cstddef>
 #include <initializer_list>
 #include <map>
-#include <algorithm>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
+#include <unordered_map>
 #include <vector>
 
 namespace Opm {
@@ -56,6 +58,12 @@ namespace Opm {
                 reservoir_water   = (1 << 8),
                 reservoir_oil     = (1 << 9),
                 reservoir_gas     = (1 << 10),
+                productivity_index_water = (1 << 11),
+                productivity_index_oil   = (1 << 12),
+                productivity_index_gas   = (1 << 13),
+                well_potential_water   = (1 << 14),
+                well_potential_oil     = (1 << 15),
+                well_potential_gas     = (1 << 16),
             };
 
             using enum_size = std::underlying_type< opt >::type;
@@ -99,6 +107,12 @@ namespace Opm {
             double reservoir_water = 0.0;
             double reservoir_oil = 0.0;
             double reservoir_gas = 0.0;
+            double productivity_index_water = 0.0;
+            double productivity_index_oil = 0.0;
+            double productivity_index_gas = 0.0;
+            double well_potential_water = 0.0;
+            double well_potential_oil = 0.0;
+            double well_potential_gas = 0.0;
     };
 
     struct Connection {
@@ -120,6 +134,18 @@ namespace Opm {
         void read(MessageBufferType& buffer);
     };
 
+    struct Segment {
+        Rates rates;
+        double pressure;
+        std::size_t segNumber;
+
+        template <class MessageBufferType>
+        void write(MessageBufferType& buffer) const;
+
+        template <class MessageBufferType>
+        void read(MessageBufferType& buffer);
+    };
+
     struct Well {
         Rates rates;
         double bhp;
@@ -127,7 +153,7 @@ namespace Opm {
         double temperature;
         int control;
         std::vector< Connection > connections;
-
+        std::unordered_map<std::size_t, Segment> segments;
         inline bool flowing() const noexcept;
         template <class MessageBufferType>
         void write(MessageBufferType& buffer) const;
@@ -249,6 +275,12 @@ namespace Opm {
             case opt::reservoir_water: return this->reservoir_water;
             case opt::reservoir_oil: return this->reservoir_oil;
             case opt::reservoir_gas: return this->reservoir_gas;
+            case opt::productivity_index_water: return this->productivity_index_water;
+            case opt::productivity_index_oil: return this->productivity_index_oil;
+            case opt::productivity_index_gas: return this->productivity_index_gas;
+            case opt::well_potential_water: return this->well_potential_water;
+            case opt::well_potential_oil: return this->well_potential_oil;
+            case opt::well_potential_gas: return this->well_potential_gas;
         }
 
         throw std::invalid_argument(
@@ -286,6 +318,12 @@ namespace Opm {
             buffer.write(this->reservoir_water);
             buffer.write(this->reservoir_oil);
             buffer.write(this->reservoir_gas);
+            buffer.write(this->productivity_index_water);
+            buffer.write(this->productivity_index_oil);
+            buffer.write(this->productivity_index_gas);
+            buffer.write(this->well_potential_water);
+            buffer.write(this->well_potential_oil);
+            buffer.write(this->well_potential_gas);
     }
 
     template <class MessageBufferType>
@@ -300,6 +338,13 @@ namespace Opm {
             buffer.write(this->effective_Kh);
     }
 
+    template <class MessageBufferType>
+    void Segment::write(MessageBufferType& buffer) const {
+        buffer.write(this->segNumber);
+        this->rates.write(buffer);
+        buffer.write(this->pressure);
+    }
+
     template <class MessageBufferType>
     void Well::write(MessageBufferType& buffer) const {
         this->rates.write(buffer);
@@ -311,6 +356,16 @@ namespace Opm {
         buffer.write(size);
         for (const Connection& comp : this->connections)
             comp.write(buffer);
+
+        {
+            const auto nSeg =
+                static_cast<unsigned int>(this->segments.size());
+            buffer.write(nSeg);
+
+            for (const auto& seg : this->segments) {
+                seg.second.write(buffer);
+            }
+        }
     }
 
     template <class MessageBufferType>
@@ -327,6 +382,12 @@ namespace Opm {
             buffer.read(this->reservoir_water);
             buffer.read(this->reservoir_oil);
             buffer.read(this->reservoir_gas);
+            buffer.read(this->productivity_index_water);
+            buffer.read(this->productivity_index_oil);
+            buffer.read(this->productivity_index_gas);
+            buffer.read(this->well_potential_water);
+            buffer.read(this->well_potential_oil);
+            buffer.read(this->well_potential_gas);
     }
 
   template <class MessageBufferType>
@@ -341,6 +402,13 @@ namespace Opm {
             buffer.read(this->effective_Kh);
    }
 
+    template <class MessageBufferType>
+    void Segment::read(MessageBufferType& buffer) {
+        buffer.read(this->segNumber);
+        this->rates.read(buffer);
+        buffer.read(this->pressure);
+    }
+
     template <class MessageBufferType>
     void Well::read(MessageBufferType& buffer) {
         this->rates.read(buffer);
@@ -348,6 +416,8 @@ namespace Opm {
         buffer.read(this->thp);
         buffer.read(this->temperature);
         buffer.read(this->control);
+
+        // Connection information
         unsigned int size = 0.0; //this->connections.size();
         buffer.read(size);
         this->connections.resize(size);
@@ -356,9 +426,25 @@ namespace Opm {
             auto& comp = this->connections[ i ];
             comp.read(buffer);
         }
+
+        // Segment information (if applicable)
+        const auto nSeg = [&buffer]() -> unsigned int
+        {
+            auto n = 0u;
+            buffer.read(n);
+
+            return n;
+        }();
+
+        for (auto segID = 0*nSeg; segID < nSeg; ++segID) {
+            auto seg = Segment{};
+            seg.read(buffer);
+
+            const auto segNumber = seg.segNumber;
+            this->segments.emplace(segNumber, std::move(seg));
+        }
     }
 
-}
-}
+}} // Opm::data
 
 #endif //OPM_OUTPUT_WELLS_HPP

opm/output/eclipse/AggregateConnectionData.hpp

@@ -0,0 +1,75 @@
+/*
+  Copyright (c) 2018 Equinor 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_AGGREGATE_CONNECTION_DATA_HPP
+#define OPM_AGGREGATE_CONNECTION_DATA_HPP
+
+#include <opm/output/eclipse/WindowedArray.hpp>
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace Opm {
+    class EclipseGrid;
+    class Schedule;
+    class UnitSystem;
+} // Opm
+
+namespace Opm { namespace data {
+    class WellRates;
+}}
+
+namespace Opm { namespace RestartIO { namespace Helpers {
+
+    class AggregateConnectionData
+    {
+    public:
+        explicit AggregateConnectionData(const std::vector<int>& inteHead);
+
+        void captureDeclaredConnData(const Opm::Schedule&        sched,
+                                     const Opm::EclipseGrid&     grid,
+                                     const Opm::UnitSystem&      units,
+                                     const Opm::data::WellRates& xw,
+                                     const std::size_t           sim_step);
+
+        const std::vector<int>& getIConn() const
+        {
+            return this->iConn_.data();
+        }
+
+        const std::vector<float>& getSConn() const
+        {
+            return this->sConn_.data();
+        }
+
+        const std::vector<double>& getXConn() const
+        {
+            return this->xConn_.data();
+        }
+
+    private:
+        WindowedMatrix<int> iConn_;
+        WindowedMatrix<float> sConn_;
+        WindowedMatrix<double> xConn_;
+    };
+
+}}} // Opm::RestartIO::Helpers
+
+#endif // OPM_AGGREGATE_CONNECTION_DATA_HPP

opm/output/eclipse/AggregateGroupData.hpp

@@ -0,0 +1,159 @@
+/*
+  Copyright (c) 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/>.
+*/
+
+#ifndef OPM_AGGREGATE_GROUP_DATA_HPP
+#define OPM_AGGREGATE_GROUP_DATA_HPP
+
+#include <opm/output/eclipse/CharArrayNullTerm.hpp>
+#include <opm/output/eclipse/WindowedArray.hpp>
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace Opm {
+    class Schedule;
+    class SummaryState;
+    class Group;
+} // Opm
+
+namespace Opm { namespace RestartIO { namespace Helpers {
+
+    class groupMaps {
+    public:
+	const std::map <size_t, const Opm::Group*>& indexGroupMap() const;
+	const std::map <const std::string, size_t>& groupNameIndexMap() const;
+
+	void currentGrpTreeNameSeqIndMap(const Opm::Schedule&                        sched,
+	                                 const size_t                                simStep,
+	                                 const std::map<const std::string , size_t>& GnIMap,
+	                                 const std::map<size_t, const Opm::Group*>&  IGMap);
+
+    private:
+	std::map <size_t, const Opm::Group*> m_indexGroupMap;
+	std::map <const std::string, size_t> m_groupNameIndexMap;
+    };
+
+    class AggregateGroupData
+    {
+    public:
+	explicit AggregateGroupData(const std::vector<int>& inteHead);
+
+	void captureDeclaredGroupData(const Opm::Schedule&                 sched,
+				      const std::vector<std::string>&      restart_group_keys,
+				      const std::vector<std::string>&      restart_field_keys,
+				      const std::map<std::string, size_t>& groupKeyToIndex,
+				      const std::map<std::string, size_t>& fieldKeyToIndex,
+				      const bool                           ecl_compatible_rst,
+				      const std::size_t                    simStep,
+				      const Opm::SummaryState&             sumState,
+				      const std::vector<int>&              inteHead);
+
+        const std::vector<int>& getIGroup() const
+        {
+            return this->iGroup_.data();
+        }
+
+        const std::vector<float>& getSGroup() const
+        {
+            return this->sGroup_.data();
+        }
+
+        const std::vector<double>& getXGroup() const
+        {
+            return this->xGroup_.data();
+        }
+
+        const std::vector<CharArrayNullTerm<8>>& getZGroup() const
+        {
+            return this->zGroup_.data();
+        }
+
+	const std::vector<std::string> restart_group_keys = {"GOPP", "GWPP", "GOPR", "GWPR", "GGPR",
+							     "GVPR", "GWIR", "GGIR", "GWCT", "GGOR",
+							     "GOPT", "GWPT", "GGPT", "GVPT", "GWIT",
+							     "GGIT"};
+
+	const std::vector<std::string> restart_field_keys = {"FOPP", "FWPP", "FOPR", "FWPR", "FGPR",
+							     "FVPR", "FWIR", "FGIR", "FWCT", "FGOR",
+							     "FOPT", "FWPT", "FGPT", "FVPT", "FWIT",
+							     "FGIT"};
+
+	const std::map<std::string, size_t> groupKeyToIndex = {
+	  {"GOPR",  0},
+	  {"GWPR",  1},
+	  {"GGPR",  2},
+	  {"GVPR",  3},
+	  {"GWIR",  5},
+	  {"GGIR",  6},
+	  {"GWCT",  8},
+	  {"GGOR",  9},
+	  {"GOPT", 10},
+	  {"GWPT", 11},
+	  {"GGPT", 12},
+	  {"GVPT", 13},
+	  {"GWIT", 15},
+	  {"GGIT", 16},
+	  {"GOPP", 22},
+	  {"GWPP", 23},
+	};
+
+	const std::map<std::string, size_t> fieldKeyToIndex = {
+	  {"FOPR",  0},
+	  {"FWPR",  1},
+	  {"FGPR",  2},
+	  {"FVPR",  3},
+	  {"FWIR",  5},
+	  {"FGIR",  6},
+	  {"FWCT",  8},
+	  {"FGOR",  9},
+	  {"FOPT", 10},
+	  {"FWPT", 11},
+	  {"FGPT", 12},
+	  {"FVPT", 13},
+	  {"FWIT", 15},
+	  {"FGIT", 16},
+	  {"FOPP", 22},
+	  {"FWPP", 23},
+	};
+
+    private:
+        /// Aggregate 'IWEL' array (Integer) for all wells.
+        WindowedArray<int> iGroup_;
+
+        /// Aggregate 'SWEL' array (Real) for all wells.
+        WindowedArray<float> sGroup_;
+
+        /// Aggregate 'XWEL' array (Double Precision) for all wells.
+        WindowedArray<double> xGroup_;
+
+        /// Aggregate 'ZWEL' array (Character) for all wells.
+        WindowedArray<CharArrayNullTerm<8>> zGroup_;
+
+        /// Maximum number of wells in a group.
+        int nWGMax_;
+
+        /// Maximum number of groups
+        int nGMaxz_;
+    };
+
+}}} // Opm::RestartIO::Helpers
+
+#endif // OPM_AGGREGATE_WELL_DATA_HPP

opm/output/eclipse/AggregateMSWData.hpp

@@ -0,0 +1,116 @@
+/*
+  Copyright (c) 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/>.
+*/
+
+#ifndef OPM_AGGREGATE_MSW_DATA_HPP
+#define OPM_AGGREGATE_MSW_DATA_HPP
+
+#include <opm/output/data/Wells.hpp>
+#include <opm/output/eclipse/CharArrayNullTerm.hpp>
+#include <opm/output/eclipse/WindowedArray.hpp>
+
+#include <string>
+#include <vector>
+
+namespace Opm {
+    class Phases;
+    class Schedule;
+    class EclipseGrid;
+    class UnitSystem;
+    class SummaryState;
+} // Opm
+
+namespace Opm { namespace RestartIO { namespace Helpers {
+
+    struct BranchSegmentPar {
+      int outletS;
+      int noSegInBranch;
+      int firstSeg;
+      int lastSeg;
+      int branch;
+    };
+
+    struct SegmentSetSourceSinkTerms {
+      std::vector<double> qosc;
+      std::vector<double> qwsc;
+      std::vector<double> qgsc;
+    };
+
+    struct SegmentSetFlowRates {
+      std::vector<double> sofr;
+      std::vector<double> swfr;
+      std::vector<double> sgfr;
+    };    
+    
+    class AggregateMSWData
+    {
+    public:
+        explicit AggregateMSWData(const std::vector<int>& inteHead);
+	
+        void captureDeclaredMSWData(const Opm::Schedule& sched,
+                                     const std::size_t    rptStep,
+				     const Opm::UnitSystem& units,
+				     const std::vector<int>& inteHead,
+				     const Opm::EclipseGrid&  grid,
+				     const Opm::SummaryState& smry,
+				     const Opm::data::WellRates&  wr
+				   );
+
+        /// Retrieve Integer Multisegment well data Array.
+        const std::vector<int>& getISeg() const
+        {
+            return this->iSeg_.data();
+        }
+
+        /// Retrieve Double precision segment data Array.
+        const std::vector<double>& getRSeg() const
+        {
+            return this->rSeg_.data();
+        }
+
+        /// Retrieve Integer multisegment well data Array for lateral branches  (ILBS)
+        const std::vector<int>& getILBs() const
+        {
+            return this->iLBS_.data();
+        }
+
+        /// Retrieve Integer multisegment well data Array for lateral branches (ILBR)
+        const std::vector<int>& getILBr() const
+        {
+            return this->iLBR_.data();
+        }
+
+
+    private:
+        /// Aggregate 'ISEG' array (Integer) for all multisegment wells
+        WindowedArray<int> iSeg_;
+
+        /// Aggregate 'RSEG' array (Double) for all multisegment wells
+        WindowedArray<double> rSeg_;
+
+        /// Aggregate 'ILBS' array (Integer) for all multisegment wells
+        WindowedArray<int> iLBS_;
+
+        /// Aggregate 'ILBR' array (Integer) for all multisegment wells
+        WindowedArray<int> iLBR_;
+
+    };
+
+}}} // Opm::RestartIO::Helpers
+
+#endif // OPM_AGGREGATE_WELL_DATA_HPP

opm/output/eclipse/AggregateWellData.hpp

@@ -44,12 +44,15 @@ namespace Opm { namespace RestartIO { namespace Helpers {
     public:
         explicit AggregateWellData(const std::vector<int>& inteHead);
 
-        void captureDeclaredWellData(const Opm::Schedule&   sched,
-                                     const Opm::UnitSystem& units,
-                                     const std::size_t      sim_step);
+	void captureDeclaredWellData(const Schedule&   	sched,
+                        const UnitSystem& 		units,
+                        const std::size_t 		sim_step,
+			const ::Opm::SummaryState&  	smry,
+			const std::vector<int>& 	inteHead);
 
         void captureDynamicWellData(const Opm::Schedule&        sched,
                                     const std::size_t           sim_step,
+				    const bool ecl_compatible_rst,
                                     const Opm::data::WellRates& xw,
                                     const Opm::SummaryState&    smry);
 
@@ -77,6 +80,8 @@ namespace Opm { namespace RestartIO { namespace Helpers {
             return this->zWell_.data();
         }
 
+        
+        
     private:
         /// Aggregate 'IWEL' array (Integer) for all wells.
         WindowedArray<int> iWell_;

opm/output/eclipse/DoubHEAD.hpp

@@ -55,7 +55,8 @@ namespace Opm { namespace RestartIO {
         DoubHEAD& timeStamp(const TimeStamp& ts);
 
         DoubHEAD& drsdt(const Schedule&   sched,
-                        const std::size_t lookup_step);
+                        const std::size_t lookup_step,
+			const double      cnvT);
 
         const std::vector<double>& data() const
         {

opm/output/eclipse/EclipseIO.hpp

@@ -41,6 +41,7 @@ namespace Opm {
 class EclipseState;
 class SummaryConfig;
 class Schedule;
+class SummaryState;
 
 /*!
  * \brief A class to write the reservoir state and the well state of a
@@ -177,7 +178,7 @@ public:
                         const std::map<std::string, double>& single_summary_values,
                         const std::map<std::string, std::vector<double>>& region_summary_values,
                         const std::map<std::pair<std::string, int>, double>& block_summary_values,
-                        bool write_double = false);
+                        const bool write_double = false);
 
 
     /*
@@ -224,6 +225,8 @@ public:
     EclipseIO( const EclipseIO& ) = delete;
     ~EclipseIO();
 
+    const SummaryState& summaryState() const;
+
 private:
     class Impl;
     std::unique_ptr< Impl > impl;

opm/output/eclipse/InteHEAD.hpp

@@ -85,6 +85,10 @@ namespace Opm { namespace RestartIO {
             int mxwsit;
             int mxwpit;
         };
+	
+	struct Group {
+	  int ngroups;
+	};
 
         InteHEAD();
         ~InteHEAD() = default;
@@ -112,6 +116,7 @@ namespace Opm { namespace RestartIO {
         InteHEAD& variousParam(const int version, const int iprog);
         InteHEAD& wellSegDimensions(const WellSegDims& wsdim);
         InteHEAD& regionDimensions(const RegDims& rdim);
+	InteHEAD& ngroups(const Group& gr);
 
         const std::vector<int>& data() const
         {

opm/output/eclipse/LogiHEAD.hpp

@@ -38,7 +38,9 @@ namespace Opm { namespace RestartIO {
 
         LogiHEAD& variousParam(const bool e300_radial,
                                const bool e100_radial,
-                               const int  nswlmx);
+                               const int  nswlmx,
+			       const bool enableHyster
+			      );
 
         const std::vector<bool>& data() const
         {

opm/output/eclipse/RestartIO.hpp

@@ -46,6 +46,7 @@ class EclipseGrid;
 class EclipseState;
 class Phases;
 class Schedule;
+class SummaryState;
 
 namespace RestartIO {
 
@@ -72,6 +73,17 @@ namespace RestartIO {
    the report step argument '99'.
 */
 
+/*void save(const std::string& filename,
+          int report_step,
+          double seconds_elapsed,
+          data::Solution cells,
+          data::Wells wells,
+          const EclipseState& es,
+          const EclipseGrid& grid,
+          const Schedule& schedule,
+          std::map<std::string, std::vector<double>> extra_data = {},
+          bool write_double = false);
+*/
 void save(const std::string& filename,
           int report_step,
           double seconds_elapsed,
@@ -79,9 +91,9 @@ void save(const std::string& filename,
           const EclipseState& es,
           const EclipseGrid& grid,
           const Schedule& schedule,
+          const SummaryState& sumState,
           bool write_double = false);
 
-
 RestartValue load( const std::string& filename,
                    int report_step,
                    const std::vector<RestartKey>& solution_keys,

opm/output/eclipse/RestartValue.hpp

@@ -71,6 +71,9 @@ namespace Opm {
         void addExtra(const std::string& key, UnitSystem::measure dimension, std::vector<double> data);
         void addExtra(const std::string& key, std::vector<double> data);
         const std::vector<double>& getExtra(const std::string& key) const;
+
+        void convertFromSI(const UnitSystem& units);
+        void convertToSI(const UnitSystem& units);
     };
 
 }

opm/output/eclipse/Summary.hpp

@@ -20,16 +20,15 @@
 #ifndef OPM_OUTPUT_SUMMARY_HPP
 #define OPM_OUTPUT_SUMMARY_HPP
 
+#include <map>
 #include <string>
 #include <vector>
-#include <unordered_map>
 
 #include <ert/ecl/ecl_sum.h>
-#include <ert/ecl/Smspec.hpp>
 
 #include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
 
-#include <opm/output/eclipse/SummaryState.hpp>
 #include <opm/output/data/Wells.hpp>
 #include <opm/output/eclipse/RegionCache.hpp>
 

opm/output/eclipse/SummaryState.hpp

@@ -1,50 +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/>.
-*/
-
-#ifndef SUMMARY_STATE_H
-#define SUMMARY_STATE_H
-
-#include <string>
-#include <unordered_map>
-
-namespace Opm{
-
-
-/*
-  The purpose of this class is to serve as a small container object for
-  computed, ready to use summary values. The values will typically be used by
-  the UDQ, WTEST and ACTIONX calculations. Observe that all value *have been
-  converted to the correct output units*.
-*/
-class SummaryState {
-public:
-    typedef std::unordered_map<std::string, double>::const_iterator const_iterator;
-
-    void add(const std::string& key, double value);
-    double get(const std::string&) const;
-    bool has(const std::string& key) const;
-
-    const_iterator begin() const;
-    const_iterator end() const;
-private:
-    std::unordered_map<std::string,double> values;
-};
-
-}
-#endif

opm/output/eclipse/VectorItems/connection.hpp

@@ -0,0 +1,74 @@
+/*
+  Copyright (c) 2018 Equinor 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_OUTPUT_ECLIPSE_VECTOR_CONNECTION_HPP
+#define OPM_OUTPUT_ECLIPSE_VECTOR_CONNECTION_HPP
+
+#include <vector>
+
+namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems {
+    namespace IConn {
+        enum index : std::vector<int>::size_type {
+            SeqIndex   =  0, // Connection sequence index
+            CellI      =  1, // I-location (1-based cell index) of connection
+            CellJ      =  2, // J-location (1-based cell index) of connection
+            CellK      =  3, // K-location (1-based cell index) of connection
+            ConnStat   =  5, // Connection status.
+                             //    > 0 => open, shut otherwise
+
+            Drainage   =  6, // Saturation function (table ID) for drainage
+            Imbibition =  9, // Saturation function (table ID) for imbibition
+
+            ComplNum   = 12, // Completion ID (1-based)
+            ConnDir    = 13, // Penetration direction (1:X, 2:Y, 3:Z)
+            Segment    = 14, // Segment ID of connection
+                             //   0 for regular connections, > 0 for MSW.
+        };
+    } // IConn
+
+    namespace SConn {
+        enum index : std::vector<float>::size_type {
+            ConnTrans    =  0, // Connection transmissibility factor
+            Depth        =  1, // Connection centre depth
+            Diameter     =  2, // Connection diameter
+
+            EffectiveKH  =  3, // Effective Kh product of connection
+
+            item12       = 11, // Unknown
+
+            SegDistEnd   = 20, // Distance to end of connection in segment
+            SegDistStart = 21, // Distance to start of connection in segment
+
+            item30       = 29, // Unknown
+            item31       = 30, // Unknown
+        };
+    } // SConn
+
+    namespace XConn {
+        enum index : std::vector<double>::size_type {
+            OilRate    =  0,  // Surface flow rate (oil)
+            WaterRate  =  1,  // Surface flow rate (water)
+            GasRate    =  2,  // Surface Flow rate (gas)
+
+            ResVRate   = 49,  // Reservoir voidage rate
+        };
+    } // XConn
+}}}} // Opm::RestartIO::Helpers::VectorItems
+
+#endif // OPM_OUTPUT_ECLIPSE_VECTOR_CONNECTION_HPP

opm/output/eclipse/VectorItems/well.hpp

@@ -41,6 +41,7 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems
             VFPTab = 11, // ID (one-based) of well's current VFP table
 
             item18 = 17, // Unknown
+	    XFlow  = 22,
             item25 = 24, // Unknown
             item32 = 31, // Unknown
             item48 = 47, // Unknown
@@ -115,6 +116,10 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems
             BHPTarget      = 6, // Well's bottom hole pressure target
 
             DatumDepth     = 9, // Well's reference depth for BHP
+	    LiqRateTarget_2  = 33, //Well's liquid rate target/limit for a well on WCONINJH control or for a producer
+	    GasRateTarget_2  = 54, //Well's gas rate target/limit for a well on WCONINJH control or for producer
+	    BHPTarget_2	   = 55, //Well's bottom hole pressure target/limit
+	    
         };
     } // SWell
 

opm/output/eclipse/WriteRestartHelpers.hpp

@@ -42,7 +42,7 @@ namespace Opm {
 namespace Opm { namespace RestartIO { namespace Helpers {
 
     const double UNIMPLEMENTED_VALUE = 1e-100; // placeholder for values not yet available 
-            
+
     std::vector<double>
     createDoubHead(const EclipseState& es,
                    const Schedule&     sched,
@@ -57,12 +57,12 @@ namespace Opm { namespace RestartIO { namespace Helpers {
                    const Schedule&     sched,
                    const double        simTime,
                    const int           num_solver_steps,
-                   const int           lookup_step,   // The integer index used to look up dynamic properties, e.g. the number of well.
-                   const int           report_step);  // The integer number this INTEHEAD keyword will be saved to, typically report_step = lookup_step + 1.
+                   const int           lookup_step);   // The integer index used to look up dynamic properties, e.g. the number of well.
 
     std::vector<bool>
     createLogiHead(const EclipseState& es);
 
+
     std::vector<int> serialize_ICON(int lookup_step, // The integer index used to look up dynamic properties, e.g. the number of well.
                                     int ncwmax,      // Max number of completions per well, should be entry 17 from createInteHead.
                                     int niconz,      // Number of elements per completion in ICON, should be entry 32 from createInteHead.

opm/parser/eclipse/Deck/Deck.hpp

@@ -147,6 +147,7 @@ namespace Opm {
             const std::string& getInputPath() const;
             const std::string& getDataFile() const;
             void setDataFile(const std::string& dataFile);
+            std::string makeDeckPath(const std::string& path) const;
 
             iterator begin();
             iterator end();

opm/parser/eclipse/EclipseState/Aquancon.hpp

@@ -44,9 +44,10 @@ namespace Opm {
             struct AquanconOutput{
                 int aquiferID;
                 std::vector<size_t> global_index;
-                std::vector<double> influx_coeff; // Size = size(global_index)
+                std::vector<std::shared_ptr<double>> influx_coeff; // Size = size(global_index)
                 std::vector<double> influx_multiplier; // Size = size(global_index)
                 std::vector<int> reservoir_face_dir; // Size = size(global_index)
+                std::vector<int> record_index;
             };
 
             Aquancon(const EclipseGrid& grid, const Deck& deck);
@@ -55,7 +56,7 @@ namespace Opm {
     
         private:
 
-            void logic_application(std::vector<Aquancon::AquanconOutput>& output_vector);
+            std::vector<Aquancon::AquanconOutput> logic_application(const std::vector<Aquancon::AquanconOutput> original_vector);
 
             void collate_function(std::vector<Aquancon::AquanconOutput>& output_vector, 
                                   std::vector<Opm::AquanconRecord>& m_aqurecord, 

opm/parser/eclipse/EclipseState/AquiferCT.hpp

@@ -58,10 +58,10 @@ namespace Opm {
                             k_a , //aquifer permeability
                             c1, // 0.008527 (METRIC, PVT-M); 0.006328 (FIELD); 3.6 (LAB)
                             h , //aquifer thickness
-                            p0, //Initial aquifer pressure at datum depth, d0
                             theta , //angle subtended by the aquifer boundary
                             c2 ; //6.283 (METRIC, PVT-M); 1.1191 (FIELD); 6.283 (LAB).
-                    
+
+                    std::shared_ptr<double> p0; //Initial aquifer pressure at datum depth, d0
                     std::vector<double> td, pi;
             };
 

opm/parser/eclipse/EclipseState/Aquifetp.hpp

@@ -0,0 +1,74 @@
+/*
+  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
+  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_AQUIFERFETP_HPP
+#define OPM_AQUIFERFETP_HPP
+
+/*
+  The Aquiferfetp which stands for AquiferFetkovich is a data container object meant to hold the data for the fetkovich aquifer model.
+  This includes the logic for parsing as well as the associated tables. It is meant to be used by opm-grid and opm-simulators in order to
+  implement the Fetkovich analytical aquifer model in OPM Flow.
+*/
+
+#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
+#include <opm/parser/eclipse/Parser/ParserKeywords/A.hpp>
+#include <opm/parser/eclipse/Deck/Deck.hpp>
+#include <opm/parser/eclipse/Deck/DeckItem.hpp>
+#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/Aqudims.hpp>
+#include <opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp>
+#include <boost/concept_check.hpp>
+#include <opm/parser/eclipse/Units/UnitSystem.hpp>
+
+namespace Opm {
+
+    class Aquifetp {
+        public:
+
+            struct AQUFETP_data{
+
+                    // Aquifer ID
+                    int aquiferID;
+                    // Table IDs
+                    int inftableID, pvttableID;
+                    std::vector<int> cell_id;
+                    // Variables constants
+                    double  J, // Specified Productivity Index
+			  rho, // water density in the aquifer
+			  C_t, // total rock compressibility
+			   V0, // initial volume of water in aquifer
+			   d0; // aquifer datum depth
+		    std::shared_ptr<double> p0; //Initial aquifer pressure at datum depth d0 - nullptr if the pressure has been defaulted.
+            };
+
+            Aquifetp(const Deck& deck);
+
+            const std::vector<Aquifetp::AQUFETP_data>& getAquifers() const;
+            int getAqPvtTabID(size_t aquiferIndex);
+    
+        private:
+  
+            std::vector<Aquifetp::AQUFETP_data> m_aqufetp;
+
+    };
+}
+
+
+#endif

opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp

@@ -93,6 +93,7 @@ namespace Opm {
         void handleEQUALREGKeyword(const DeckKeyword& deckKeyword );
         void handleMULTIREGKeyword(const DeckKeyword& deckKeyword );
         void handleOPERATEKeyword( const DeckKeyword& deckKeyword, BoxManager& boxManager);
+        void handleOPERATERKeyword( const DeckKeyword& deckKeyword);
 
         void loadGridPropertyFromDeckKeyword(const Box& inputBox,
                                              const DeckKeyword& deckKeyword);

opm/parser/eclipse/EclipseState/EclipseConfig.hpp

@@ -29,11 +29,13 @@
 namespace Opm {
 
     class Deck;
+    class ParseContext;
+    class ErrorGuard;
 
     class EclipseConfig
     {
     public:
-        EclipseConfig(const Deck& deck);
+        EclipseConfig(const Deck& deck, const ParseContext& parseContext, ErrorGuard& errors);
 
         const InitConfig& init() const;
         const IOConfig& io() const;

opm/parser/eclipse/EclipseState/EclipseState.hpp

@@ -23,15 +23,17 @@
 #include <memory>
 #include <vector>
 
+#include <opm/parser/eclipse/Parser/ErrorGuard.hpp>
+#include <opm/parser/eclipse/Parser/ParseContext.hpp>
 #include <opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp>
 #include <opm/parser/eclipse/EclipseState/EclipseConfig.hpp>
+#include <opm/parser/eclipse/EclipseState/Edit/EDITNNC.hpp>
 #include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
 #include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
 #include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
 #include <opm/parser/eclipse/EclipseState/Grid/TransMult.hpp>
 #include <opm/parser/eclipse/EclipseState/Runspec.hpp>
 #include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
-#include <opm/parser/eclipse/Parser/ParseContext.hpp>
 #include <opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp>
 
 namespace Opm {
@@ -64,9 +66,11 @@ namespace Opm {
             AllProperties = IntProperties | DoubleProperties
         };
 
-        EclipseState(const Deck& deck , ParseContext parseContext = ParseContext());
+        template<typename T>
+        EclipseState(const Deck& deck , const ParseContext& parseContext, T&& errors);
+        EclipseState(const Deck& deck , const ParseContext& parseContext, ErrorGuard& errors);
+        EclipseState(const Deck& deck);
 
-        const ParseContext& getParseContext() const;
         const IOConfig& getIOConfig() const;
         IOConfig& getIOConfig();
 
@@ -85,6 +89,11 @@ namespace Opm {
         const NNC& getInputNNC() const;
         bool hasInputNNC() const;
 
+        /// editing non-neighboring connections
+        /// the non-standard adjacencies as specified in input deck
+        const EDITNNC& getInputEDITNNC() const;
+        bool hasInputEDITNNC() const;
+
         const Eclipse3DProperties& get3DProperties() const;
         const TableManager& getTableManager() const;
         const EclipseConfig& getEclipseConfig() const;
@@ -112,12 +121,12 @@ namespace Opm {
         void complainAboutAmbiguousKeyword(const Deck& deck,
                                            const std::string& keywordName);
 
-        ParseContext m_parseContext;
         const TableManager m_tables;
         Runspec m_runspec;
         EclipseConfig m_eclipseConfig;
         UnitSystem m_deckUnitSystem;
         NNC m_inputNnc;
+        EDITNNC m_inputEditNnc;
         EclipseGrid m_inputGrid;
         Eclipse3DProperties m_eclipseProperties;
         const SimulationConfig m_simulationConfig;

opm/parser/eclipse/EclipseState/Edit/EDITNNC.hpp

@@ -0,0 +1,48 @@
+/*
+  Copyright 2018 Equinor AS
+
+  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_COMMON_EDITNNC_HPP
+#define OPM_COMMON_EDITNNC_HPP
+
+#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
+namespace Opm
+{
+
+/// Represents edit information for non-neighboring connections (NNCs, faults, etc.)
+class EDITNNC
+{
+public:
+    EDITNNC() = default;
+
+    /// Construct from input deck
+    explicit EDITNNC(const Deck& deck);
+    /// \brief Get an ordered set of EDITNNC
+    const std::vector<NNCdata>& data() const
+    {
+        return m_editnnc;
+    }
+    /// \brief Get the number of entries
+    size_t size() const;
+    /// \brief Whether EDITNNC was empty.
+    bool empty() const;
+
+private:
+    std::vector<NNCdata> m_editnnc;
+};
+}
+#endif // OPM_COMMON_EDITNNC_HPP

opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp

@@ -38,6 +38,7 @@ namespace Opm {
 
     class Deck;
     class ZcornMapper;
+    class NNC;
 
     /**
        About cell information and dimension: The actual grid
@@ -76,6 +77,8 @@ namespace Opm {
         /// explicitly.  If a null pointer is passed, every cell is active.
         EclipseGrid(const Deck& deck, const int * actnum = nullptr);
 
+
+        static bool hasGDFILE(const Deck& deck);
         static bool hasCylindricalKeywords(const Deck& deck);
         static bool hasCornerPointKeywords(const Deck&);
         static bool hasCartesianKeywords(const Deck&);
@@ -85,6 +88,8 @@ namespace Opm {
         size_t activeIndex(size_t i, size_t j, size_t k) const;
         size_t activeIndex(size_t globalIndex) const;
 
+        void save(const std::string& filename, UnitSystem::UnitType output_units) const;
+        void addNNC(const NNC& nnc);
         /*
           Observe that the there is a getGlobalIndex(i,j,k)
           implementation in the base class. This method - translating
@@ -107,7 +112,7 @@ namespace Opm {
         PinchMode::ModeEnum getMultzOption( ) const;
 
         MinpvMode::ModeEnum getMinpvMode() const;
-        double getMinpvValue( ) const;
+        const std::vector<double>& getMinpvVector( ) const;
 
 
         /*
@@ -176,7 +181,7 @@ namespace Opm {
         const ecl_grid_type * c_ptr() const;
 
     private:
-        double m_minpvValue;
+        std::vector<double> m_minpvVector;
         MinpvMode::ModeEnum m_minpvMode;
         Value<double> m_pinch;
         PinchMode::ModeEnum m_pinchoutMode;
@@ -200,6 +205,7 @@ namespace Opm {
                 ert_ptr( ecl_grid_alloc_copy( src.get() ) ) {}
         };
         grid_ptr m_grid;
+        void initBinaryGrid(const Deck& deck);
 
         void initCornerPointGrid(const std::array<int,3>& dims ,
                                  const std::vector<double>& coord ,

opm/parser/eclipse/EclipseState/Grid/GridDims.hpp

@@ -42,6 +42,7 @@ namespace Opm {
 
         size_t getNY() const;
         size_t getNZ() const;
+        size_t operator[](int dim) const;
 
         const std::array<int, 3> getNXYZ() const;
 
@@ -64,6 +65,7 @@ namespace Opm {
 
     private:
         void init(const DeckKeyword& keyword);
+        void binary_init(const Deck& deck);
     };
 }
 

opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp

@@ -141,12 +141,13 @@ namespace Opm {
         void handleMULTIPLYRecord( const DeckRecord& record, BoxManager& boxManager);
         void handleCOPYRecord( const DeckRecord& record, BoxManager& boxManager);
         void handleEQUALSRecord( const DeckRecord& record, BoxManager& boxManager);
+        void handleOPERATERecord( const DeckRecord& record , BoxManager& boxManager);
 
         void handleEQUALREGRecord( const DeckRecord& record, const GridProperty<int>& regionProperty );
         void handleADDREGRecord( const DeckRecord& record, const GridProperty<int>& regionProperty );
         void handleMULTIREGRecord( const DeckRecord& record, const GridProperty<int>& regionProperty );
         void handleCOPYREGRecord( const DeckRecord& record, const GridProperty<int>& regionProperty );
-        void handleOPERATERecord( const DeckRecord& record , BoxManager& boxManager);
+        void handleOPERATERRecord( const DeckRecord& record , const GridProperty<int>& regionProperty );
         /*
           Iterators over initialized properties. The overloaded
           operator*() opens the pair which comes natively from the
@@ -184,6 +185,11 @@ namespace Opm {
                             const std::string& dimString,
                             const bool defaultInitializable );
 
+        void postAddKeyword(const std::string& name,
+                            std::function< std::vector< T >(size_t) > initProcessor,
+                            const std::string& dimString);
+
+
         GridProperty<T>& getKeyword(const std::string& keyword);
         bool addAutoGeneratedKeyword_(const std::string& keywordName) const;
         void insertKeyword(const SupportedKeywordInfo& supportedKeyword) const;

opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp

@@ -177,13 +177,91 @@ public:
        grid and call the cellsEqual( T , std::vector<int>&) overload,
        otherwise it will return indexEqual( value );
      */
-     std::vector<size_t>  cellsEqual(T value, const EclipseGrid& grid, bool active = true)  const;
-
+     std::vector<size_t>  cellsEqual(T value, const EclipseGrid& grid, bool active = true)  const; 
     /*
       Will return a std::vector<T> of the data in the active cells.
     */
      std::vector<T> compressedCopy( const EclipseGrid& grid) const;
 
+
+    /*
+      The grid properties like PORO and SATNUM can be created in essentially two
+      ways; either they can be explicitly assigned in the deck as:
+
+        PORO
+           1000*0.15 /
+
+      or they can be created indirectly through various mathematical operations
+      like:
+
+         MULTIPLY
+            TRANX 0.20 /
+         /
+
+      The deckAssigned() property is used so that we can differentiate between
+      properties which have been explicitly assigned/loaded from the deck, and
+      those where the default construction has been invoked. This functionality
+      is implemented purely to support the TRAN? keywords. The transmissibility
+      is be default calculated by the simulator code, but the TRAN keywords can
+      be used in the deck to manipulate this calculation in two different ways:
+
+         1. TRAN explicitly assigned in GRID section
+         ===========================================
+         ...
+         TRANX
+            1000*0.026 /
+
+         COPY
+            'TRANX'  'TRANY' /
+         /
+
+         In this case the simulator should detect that the input deck has TRANX
+         specified and just use the input values from the deck. This is the
+         normal handling of keywords, and agrees with e.g. PERMX and PORO. This
+         also applies when the COPY keyword has been used, as in the case of
+         'TRANY' above.
+
+
+         2. TRAN modifier present in EDIT section
+         ========================================
+         The scenario here is that there is no mention of TRANX in the GRID
+         section, however the EDIT section contains modifiers like this:
+
+         MULTIPLY
+             TRANX  0.25 /
+
+         I.e. we request the TRANX values to be reduced with a factor of 0.25. In
+         this case the simulator should still calculate transmissibility according
+         to it's normal algorithm, and then subsequently scale that result with a
+         factor of 0.25.
+
+         In this case the input layer needs to autocreate a TRANX keyword,
+         defaulted to 1.0 and then scale that to 0.25.
+
+
+      Now - the important point is that when doing transmissibility calculations
+      the simulator must be able to distinguish between cases 1 and 2,
+      specifically whether the TRANX keyword should be interpreted as absolute
+      values(case 1) or as a multiplier(case 2). That is the purpose of the
+      deckAssigned() property. Pseudo code for the transmissibility calculations
+      in the simulator could be:
+
+
+          const auto& input_tranx = properties.getKeyword("TRANX");
+          if (input_tranx.deckAssigned()) {
+               // set simulator internal transmissibilities to values from input_tranx
+               tranx = input_tranx;
+          } else {
+               // Calculate transmissibilities according to normal simulator algorithm
+               ...
+               ...
+               // Scale transmissibilities with scale factor from input_tranx
+               tranx *= input_tranx;
+          }
+
+     */
+    bool deckAssigned() const;
+
 private:
     const DeckItem& getDeckItem( const DeckKeyword& );
     void setDataPoint(size_t sourceIdx, size_t targetIdx, const DeckItem& deckItem);
@@ -192,6 +270,7 @@ private:
     SupportedKeywordInfo m_kwInfo;
     std::vector<T> m_data;
     bool m_hasRunPostProcessor = false;
+    bool assigned = false;
 };
 
 // initialize the TEMPI grid property using the temperature vs depth

opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp

@@ -50,16 +50,13 @@ namespace Opm {
 
 
 
-    class MULTREGTRecord {
-    public:
-        MULTREGTRecord(const DeckRecord& deckRecord , const std::string& defaultRegion);
-
-        Value<int> m_srcRegion;
-        Value<int> m_targetRegion;
-        double m_transMultiplier;
-        int m_directions;
-        MULTREGT::NNCBehaviourEnum m_nncBehaviour;
-        Value<std::string>  m_region;
+    struct MULTREGTRecord {
+        int src_value;
+        int target_value;
+        double trans_mult;
+        int directions;
+        MULTREGT::NNCBehaviourEnum nnc_behaviour;
+        std::string region_name;
     };
 
     typedef std::map< std::pair<int , int> , const MULTREGTRecord * >  MULTREGTSearchMap;
@@ -75,7 +72,7 @@ namespace Opm {
         double getRegionMultiplier(size_t globalCellIdx1, size_t globalCellIdx2, FaceDir::DirEnum faceDir) const;
 
     private:
-        void addKeyword( const DeckKeyword& deckKeyword, const std::string& defaultRegion);
+        void addKeyword( const Eclipse3DProperties& props, const DeckKeyword& deckKeyword, const std::string& defaultRegion);
         void assertKeywordSupported(const DeckKeyword& deckKeyword, const std::string& defaultRegion);
         std::vector< MULTREGTRecord > m_records;
         std::map<std::string , MULTREGTSearchMap> m_searchMap;

opm/parser/eclipse/EclipseState/Grid/NNC.hpp

@@ -28,6 +28,10 @@ namespace Opm
 {
 
 struct NNCdata {
+    NNCdata(size_t c1, size_t c2, double t)
+        : cell1(c1), cell2(c2), trans(t)
+    {}
+    NNCdata() = default;
     size_t cell1;
     size_t cell2;
     double trans;

opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp

@@ -105,6 +105,41 @@ namespace Opm {
       ------ Default ------
       If no keywords for config of writing restart files have been handled; no restart files are written.
 
+
+      ECL compatible restart
+      ======================
+
+      Unfortunately flow & eclipse are not compatible across restarts. The
+      RestartIO implementation can write restart files for flow -> flow restart
+      or alternatively for flow -> eclipse restart. This is regulated by the
+      boolean flag ecl_compatible_restart in the IOConfig class. The difference
+      between the two are as follows:
+
+      ecl_compatible_restart = false:
+
+        1. The 'extra' fields in the RestartValue structure are actually
+           written to disk.
+
+        2. You can optionally ask the RestartIO::save() function to save the
+           solution in double precision.
+
+        3. The RestartIO::save() function will save opm specific vector OPM_IWEL
+           and OPM_XWEL.
+
+      ecl_compatible_restart = true:
+
+        1. The 'extra' fields in the RestartValue are silently ignored.
+
+        2. If request double precision solution data that is silently ignored,
+           it will be float.
+
+        3. The OPM_IWEL and OPM_XWEL vectors will not be written.
+
+      Observe that the solution data in the RestartValue is passed
+      unconditionally to the solution section in the restart file, so if you
+      pass a field in the solution section which Eclipse does not recognize you
+      will end up with a restart file which Eclipse can not read, even if you
+      have set ecl_compatible_restart to true.
     */
 
 
@@ -117,7 +152,8 @@ namespace Opm {
         explicit IOConfig( const Deck& );
         explicit IOConfig( const std::string& input_path );
 
-
+        void setEclCompatibleRST(bool ecl_rst);
+        bool getEclCompatibleRST() const;
         bool getWriteEGRIDFile() const;
         bool getWriteINITFile() const;
         bool getUNIFOUT() const;
@@ -138,7 +174,7 @@ namespace Opm {
         void setOutputDir(const std::string& outputDir);
 
         const std::string& getBaseName() const;
-        void setBaseName(std::string baseName);
+        void setBaseName(const std::string& baseName);
 
         /// Return a string consisting of outputpath and basename;
         /// i.e. /path/to/sim/CASE
@@ -163,8 +199,9 @@ namespace Opm {
         std::string     m_deck_filename;
         bool            m_output_enabled = true;
         std::string     m_output_dir;
-        std::string     m_base_name;
         bool            m_nosim;
+        std::string     m_base_name;
+        bool            ecl_compatible_rst = true;
 
         IOConfig( const GRIDSection&,
                   const RUNSPECSection&,

opm/parser/eclipse/EclipseState/IOConfig/RestartConfig.hpp

@@ -200,7 +200,8 @@ namespace Opm {
     class SOLUTIONSection;
     class TimeMap;
     class Schedule;
-
+    class ParseContext;
+    class ErrorGuard;
 
     /*The IOConfig class holds data about input / ouput configurations
 
@@ -317,19 +318,27 @@ namespace Opm {
     public:
 
         RestartConfig();
-        explicit RestartConfig( const Deck& );
+
+        template<typename T>
+        RestartConfig( const Deck&, const ParseContext& parseContext, T&& errors );
+
+        RestartConfig( const Deck&, const ParseContext& parseContext, ErrorGuard& errors );
+        RestartConfig( const Deck& );
+
         RestartConfig( const SCHEDULESection& schedule,
                        const SOLUTIONSection& solution,
+                       const ParseContext& parseContext,
+                       ErrorGuard& errors,
                        TimeMap timemap );
 
 
         int  getFirstRestartStep() const;
-        bool getWriteRestartFile(size_t timestep) const;
+        bool getWriteRestartFile(size_t timestep, bool log=true) const;
         const std::map< std::string, int >& getRestartKeywords( size_t timestep ) const;
         int getKeyword( const std::string& keyword, size_t timeStep) const;
 
         void overrideRestartWriteInterval(size_t interval);
-        void handleSolutionSection(const SOLUTIONSection& solutionSection);
+        void handleSolutionSection(const SOLUTIONSection& solutionSection, const ParseContext& parseContext, ErrorGuard& errors);
         void setWriteInitialRestartFile(bool writeInitialRestartFile);
 
         RestartSchedule getNode( size_t timestep ) const;
@@ -356,12 +365,13 @@ namespace Opm {
         int     m_first_restart_step;
         bool    m_write_initial_RST_file = false;
 
-        void handleScheduleSection( const SCHEDULESection& schedule);
+        void handleScheduleSection( const SCHEDULESection& schedule, const ParseContext& parseContext, ErrorGuard& errors);
         void update( size_t step, const RestartSchedule& rs);
         static RestartSchedule rptsched( const DeckKeyword& );
 
         DynamicState< RestartSchedule > restart_schedule;
         DynamicState< std::map< std::string, int > > restart_keywords;
+        std::vector< bool > save_keywords;
     };
 } //namespace Opm
 

opm/parser/eclipse/EclipseState/Runspec.hpp

@@ -24,7 +24,7 @@
 
 #include <opm/parser/eclipse/EclipseState/Tables/Tabdims.hpp>
 #include <opm/parser/eclipse/EclipseState/EndpointScaling.hpp>
-#include <opm/parser/eclipse/EclipseState/UDQConfig.hpp>
+#include <opm/parser/eclipse/EclipseState/UDQParams.hpp>
 
 namespace Opm {
 class Deck;
@@ -75,7 +75,12 @@ public:
         return this->nGMax;
     }
 
+        int maxWellsInField() const
+    {
+        return this->nWMax;
+    }
 private:
+    int nWMax  { 0 };
     int nCWMax { 0 };
     int nWGMax { 0 };
     int nGMax  { 0 };
@@ -107,17 +112,61 @@ private:
     int nLatBranchMax;
 };
 
+class EclHysterConfig
+{
+public:
+    explicit EclHysterConfig(const Deck& deck);
+
+
+    /*!
+     * \brief Specify whether hysteresis is enabled or not.
+     */
+    //void setActive(bool yesno);
+
+    /*!
+     * \brief Returns whether hysteresis is enabled (active).
+     */
+    bool active() const;
+
+    /*!
+     * \brief Return the type of the hysteresis model which is used for capillary pressure.
+     *
+     * -1: capillary pressure hysteresis is disabled
+     * 0: use the Killough model for capillary pressure hysteresis
+     */
+    int pcHysteresisModel() const;
+
+    /*!
+     * \brief Return the type of the hysteresis model which is used for relative permeability.
+     *
+     * -1: relperm hysteresis is disabled
+     * 0: use the Carlson model for relative permeability hysteresis
+     */
+    int krHysteresisModel() const;
+
+private:
+    // enable hysteresis at all
+    bool activeHyst  { false };
+
+    // the capillary pressure and the relperm hysteresis models to be used
+    int pcHystMod { 0 };
+    int krHystMod { 0 };
+};
+
+
+
 class Runspec {
    public:
         explicit Runspec( const Deck& );
 
-        const UDQConfig& udqConfig() const noexcept;
+        const UDQParams& udqParams() const noexcept;
         const Phases& phases() const noexcept;
         const Tabdims&  tabdims() const noexcept;
         const EndpointScaling& endpointScaling() const noexcept;
         const Welldims& wellDimensions() const noexcept;
         const WellSegmentDims& wellSegmentDimensions() const noexcept;
         int eclPhaseMask( ) const noexcept;
+	const EclHysterConfig& hysterPar() const noexcept;
 
    private:
         Phases active_phases;
@@ -125,9 +174,11 @@ class Runspec {
         EndpointScaling endscale;
         Welldims welldims;
         WellSegmentDims wsegdims;
-        UDQConfig udq_config;
+        UDQParams udq_params;
+	EclHysterConfig hystpar;
 };
 
+
 }
 
 #endif // OPM_RUNSPEC_HPP

opm/parser/eclipse/EclipseState/Schedule/Action/ActionAST.hpp

@@ -0,0 +1,50 @@
+/*
+  Copyright 2018 Equinor 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 ActionAST_HPP
+#define ActionAST_HPP
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Opm {
+
+class ActionContext;
+class ASTNode;
+
+
+
+class ActionAST{
+public:
+    ActionAST() = default;
+    explicit ActionAST(const std::vector<std::string>& tokens);
+    bool eval(const ActionContext& context, std::vector<std::string>& matching_wells) const;
+private:
+    /*
+      The use of a pointer here is to be able to create this class with only a
+      forward declaration of the ASTNode class. Would have prefered to use a
+      unique_ptr, but that requires writing custom destructors - the use of a
+      shared_ptr does not imply any shared ownership.
+    */
+    std::shared_ptr<ASTNode> condition;
+};
+}
+#endif

opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.hpp

@@ -0,0 +1,55 @@
+/*
+  Copyright 2018 Equinor 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 ActionContext_HPP
+#define ActionContext_HPP
+
+#include <string>
+#include <map>
+
+#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
+
+namespace Opm {
+
+class ActionContext {
+public:
+    /*
+      Observe that the ActionContext takes a copy of the SummaryState object.
+    */
+    explicit ActionContext(const SummaryState& summary_state);
+
+    /*
+      The get methods will first check the internal storage in the 'values' map
+      and then subsequently query the SummaryState member.
+    */
+    double get(const std::string& func, const std::string& arg) const;
+    void   add(const std::string& func, const std::string& arg, double value);
+
+    double get(const std::string& func) const;
+    void   add(const std::string& func, double value);
+
+    std::vector<std::string> wells(const std::string& func) const;
+
+private:
+    SummaryState summary_state;
+    std::map<std::string, double> values;
+};
+}
+#endif

opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp

@@ -22,6 +22,11 @@
 #define ActionX_HPP_
 
 #include <string>
+#include <vector>
+#include <ctime>
+
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/Action/ActionAST.hpp>
 
 namespace Opm {
 /*
@@ -49,21 +54,36 @@ namespace Opm {
 */
 
 class DeckKeyword;
+class ActionContext;
 
 class ActionX {
 public:
-    ActionX(const std::string& name, size_t max_run, double max_wait);
-    explicit ActionX(const DeckKeyword& kw);
+    ActionX(const std::string& name, size_t max_run, double max_wait, std::time_t start_time);
+    ActionX(const DeckKeyword& kw, std::time_t start_time);
+    ActionX(const DeckRecord& record, std::time_t start_time);
 
     void addKeyword(const DeckKeyword& kw);
+    bool ready(std::time_t sim_time) const;
+    bool eval(std::time_t sim_time, const ActionContext& context, std::vector<std::string>& wells) const;
 
-    const std::string& name() const;
+
+    std::string name() const { return this->m_name; }
+    size_t max_run() const { return this->m_max_run; }
+    double min_wait() const { return this->m_min_wait; }
+    std::time_t start_time() const { return this->m_start_time; }
+    std::vector<DeckKeyword>::const_iterator begin() const;
+    std::vector<DeckKeyword>::const_iterator end() const;
+    static bool valid_keyword(const std::string& keyword);
 private:
     std::string m_name;
-    size_t max_run;
-    double max_wait;
+    size_t m_max_run = 0;
+    double m_min_wait = 0.0;
+    std::time_t m_start_time;
 
     std::vector<DeckKeyword> keywords;
+    ActionAST condition;
+    mutable size_t run_count = 0;
+    mutable std::time_t last_run = 0;
 };
 
 }

opm/parser/eclipse/EclipseState/Schedule/Action/Actions.hpp

@@ -0,0 +1,45 @@
+/*
+  Copyright 2018 Equinor 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 ActionCOnfig_HPP
+#define ActionCOnfig_HPP
+
+#include <string>
+#include <ctime>
+#include <map>
+
+#include <opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp>
+
+namespace Opm {
+
+class Actions {
+public:
+    Actions() = default;
+    size_t size() const;
+    bool empty() const;
+    void add(const ActionX& action);
+    bool ready(std::time_t sim_time) const;
+    ActionX& at(const std::string& name);
+    std::vector<const ActionX *> pending(std::time_t sim_time) const;
+private:
+    std::map<std::string, ActionX> actions;
+};
+}
+#endif

opm/parser/eclipse/EclipseState/Schedule/Connection.hpp

@@ -22,15 +22,16 @@
 #define COMPLETION_HPP_
 
 #include <array>
+#include <cstddef>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
+
 #include <opm/parser/eclipse/Parser/ParseContext.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
 #include <opm/parser/eclipse/EclipseState/Util/Value.hpp>
 
-
 namespace Opm {
 
     class DeckKeyword;
@@ -41,50 +42,80 @@ namespace Opm {
         Connection(int i, int j , int k ,
                    int complnum,
                    double depth,
-                   WellCompletion::StateEnum state ,
-                   const Value<double>& connectionTransmissibilityFactor,
-                   const Value<double>& diameter,
-                   const Value<double>& skinFactor,
-                   const Value<double>& Kh,
+                   WellCompletion::StateEnum state,
+                   double CF,
+                   double Kh,
+                   double rw,
+                   double r0,
+                   double skin_factor,
                    const int satTableId,
-                   const WellCompletion::DirectionEnum direction);
+                   const WellCompletion::DirectionEnum direction,
+		   const std::size_t seqIndex,
+		   const double segDistStart,
+		   const double segDistEnd,
+		   const bool defaultSatTabId
+		  );
 
 
+        bool attachedToSegment() const;
         bool sameCoordinate(const int i, const int j, const int k) const;
         int getI() const;
         int getJ() const;
         int getK() const;
-        double getConnectionTransmissibilityFactor() const;
-        double getDiameter() const;
-        double getSkinFactor() const;
-        bool attachedToSegment() const;
-        const Value<double>& getConnectionTransmissibilityFactorAsValueObject() const;
-        const Value<double>& getEffectiveKhAsValueObject() const;
+        WellCompletion::StateEnum state() const;
+        WellCompletion::DirectionEnum dir() const;
+        double depth() const;
+        int satTableId() const;
+        int complnum() const;
+        int segment() const;
+        double CF() const;
+        double Kh() const;
+        double rw() const;
+        double r0() const;
+        double skinFactor() const;
+        double wellPi() const;
+
+        void setState(WellCompletion::StateEnum state);
+        void setComplnum(int compnum);
+        void scaleWellPi(double wellPi);
+        void updateSegment(int segment_number, double center_depth, std::size_t seqIndex);
+	const std::size_t& getSeqIndex() const;
+	const bool& getDefaultSatTabId() const;
+	const std::size_t& getCompSegSeqIndex() const;
+	void setCompSegSeqIndex(std::size_t index);
+	void setDefaultSatTabId(bool id);
+	const double& getSegDistStart() const;
+	const double& getSegDistEnd() const;
+	void setSegDistStart(const double& distStart);
+	void setSegDistEnd(const double& distEnd);
 
         bool operator==( const Connection& ) const;
         bool operator!=( const Connection& ) const;
-
-        WellCompletion::DirectionEnum dir;
-        double center_depth;
-        WellCompletion::StateEnum state;
-        int sat_tableId;
-        int complnum;
-
     private:
-        std::array<int,3> ijk;
-        Value<double> m_diameter;
-        Value<double> m_connectionTransmissibilityFactor;
-        Value<double> m_skinFactor;
-        Value<double> m_Kh;
+        WellCompletion::DirectionEnum direction;
+        double center_depth;
+        WellCompletion::StateEnum open_state;
+        int sat_tableId;
+        int m_complnum;
+        double m_CF;
+        double m_Kh;
+        double m_rw;
+        double m_r0;
+        double m_skin_factor;
+
+        std::array<int,3> ijk;
+	std::size_t m_seqIndex;
+	double m_segDistStart;
+	double m_segDistEnd;
+	bool m_defaultSatTabId;
+	std::size_t m_compSeg_seqIndex=0;
 
-    public:
         // related segment number
         // -1 means the completion is not related to segment
         int segment_number = -1;
-        double wellPi = 1.0;
+        double wPi = 1.0;
     };
 }
 
-
-
 #endif /* COMPLETION_HPP_ */
+

opm/parser/eclipse/EclipseState/Schedule/DynamicState.hpp

@@ -114,6 +114,35 @@ class DynamicState {
             this->m_data[index] = value;
         }
 
+
+    /*
+      Will assign all currently equal values starting at index with the new
+      value. Purpose of the method is to support manipulations of an existing
+      Schedule object, if e.g. a well is initially closed in the interval
+      [T1,T2] and then opened at time T1 < Tx < T2 then the open should be
+      applied for all times in the range [Tx,T2].
+    */
+    void update_equal(size_t index, const T& value) {
+        if (this->m_data.size() <= index)
+            throw std::out_of_range("Invalid index for update_equal()");
+
+        const T prev_value = this->m_data[index];
+        if (prev_value == value)
+            return;
+
+        while (true) {
+            if (this->m_data[index] != prev_value)
+                break;
+
+            this->m_data[index] = value;
+
+            index++;
+            if (index == this->m_data.size())
+                break;
+
+        }
+    }
+
         /// Will return the index of the first occurence of @value, or
         /// -1 if @value is not found.
         int find(const T& value) const {

opm/parser/eclipse/EclipseState/Schedule/Group.hpp

@@ -24,6 +24,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <stddef.h>
 
 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
 #include <opm/parser/eclipse/EclipseState/Runspec.hpp>
@@ -66,9 +67,10 @@ namespace Opm {
 
     class Group {
     public:
-        Group(const std::string& name, const TimeMap& timeMap , size_t creationTimeStep);
+        Group(const std::string& name, const size_t& seqIndex, const TimeMap& timeMap , size_t creationTimeStep);
         bool hasBeenDefined(size_t timeStep) const;
         const std::string& name() const;
+	const size_t& seqIndex() const;
         bool isProductionGroup(size_t timeStep) const;
         bool isInjectionGroup(size_t timeStep) const;
         void setProductionGroup(size_t timeStep, bool isProductionGroup);
@@ -133,6 +135,7 @@ namespace Opm {
     private:
         size_t m_creationTimeStep;
         std::string m_name;
+	size_t m_seqIndex;
         GroupInjection::InjectionData m_injection;
         GroupProduction::ProductionData m_production;
         DynamicState< std::set< std::string > > m_wells;

opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp

@@ -22,17 +22,21 @@
 
 #include <string>
 #include <vector>
+#include <map>
 
 namespace Opm {
 
 class GroupTree {
     public:
-        void update( const std::string& name );
-        void update( const std::string& name, const std::string& parent );
+        void update( const std::string& name);
+        void update( const std::string& name, const std::string& parent);
+	void updateSeqIndex( const std::string& name, const std::string& other_parent);
         bool exists( const std::string& group ) const;
         const std::string& parent( const std::string& name ) const;
         std::vector< std::string > children( const std::string& parent ) const;
-
+	const std::map<std::string , size_t>& nameSeqIndMap() const;
+	const std::map<size_t, std::string >& seqIndNameMap() const;
+	size_t groupTreeSize();
         bool operator==( const GroupTree& ) const;
         bool operator!=( const GroupTree& ) const;
 
@@ -53,6 +57,8 @@ class GroupTree {
         std::vector< group > groups = { group { "FIELD", "" } };
         friend bool operator<( const std::string&, const group& );
         std::vector< group >::iterator find( const std::string& );
+	std::map<std::string , size_t> m_nameSeqIndMap;
+	std::map<size_t, std::string > m_seqIndNameMap;
 };
 
 }

opm/parser/eclipse/EclipseState/Schedule/MSW/updatingConnectionsWithSegments.hpp

@@ -24,9 +24,11 @@
 
 #include <opm/parser/eclipse/EclipseState/Schedule/WellConnections.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp>
+#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
 
 namespace Opm {
-    WellConnections * newConnectionsWithSegments(const DeckKeyword& compsegs, const WellConnections& input_connections, const WellSegments& segments);
+    WellConnections * newConnectionsWithSegments(const DeckKeyword& compsegs, const WellConnections& input_connections, 
+						 const WellSegments& segments, const EclipseGrid& grid, std::size_t& totNC);
 }
 
 #endif

opm/parser/eclipse/EclipseState/Schedule/OilVaporizationProperties.hpp

@@ -21,6 +21,7 @@
 
 #include <string>
 #include <memory>
+#include <vector>
 
 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
 
@@ -28,24 +29,27 @@ namespace Opm
 {
      /*
      * The OilVaporizationProperties class
-     * This classe is used to store the values from {VAPPARS, DRSDT, DRVDT} the behavior of the keywords are mutal exclusive.
-     * Any one of the three keywords {VAPPARS, DRSDT, DRVDT} will cancel previous settings of the other keywords.
+     * This classe is used to store the values from {VAPPARS, DRSDT, DRVDT}
+     * The VAPPARS and {DRSDT, DRVDT} are mutal exclusive and will cancel previous settings of the other keywords.
      * Ask for type first and the ask for the correct values for this type, asking for values not valid for the current type will throw a logic exception.
      */
     class OilVaporizationProperties {
     public:
-        OilVaporizationProperties() = default;
-        static OilVaporizationProperties createDRSDT(double maxDRSDT, const std::string& option);
-        static OilVaporizationProperties createDRVDT(double maxDRVDT);
-        static OilVaporizationProperties createVAPPARS(double vap1, double vap2);
+        explicit OilVaporizationProperties(const size_t numPvtReginIdx);
+        static void updateDRSDT(Opm::OilVaporizationProperties& ovp, const std::vector<double>& maxDRSDT, const std::vector<std::string>& option);
+        static void updateDRVDT(Opm::OilVaporizationProperties& ovp, const std::vector<double>& maxDRVDT);
+        static void updateVAPPARS(Opm::OilVaporizationProperties& ovp, const std::vector<double>& vap1, const std::vector<double>& vap2);
 
         Opm::OilVaporizationEnum getType() const;
-        double getVap1() const;
-        double getVap2() const;
-        double getMaxDRSDT() const;
-        double getMaxDRVDT() const;
-        bool getOption() const;
+        double getVap1(const size_t pvtRegionIdx) const;
+        double getVap2(const size_t pvtRegionIdx) const;
+        double getMaxDRSDT(const size_t pvtRegionIdx) const;
+        double getMaxDRVDT(const size_t pvtRegionIdx) const;
+        bool getOption(const size_t pvtRegionIdx) const;
+        bool drsdtActive() const;
+        bool drvdtActive() const;
         bool defined() const;
+        size_t numPvtRegions() const {return m_maxDRSDT.size();}
 
         /*
          * if either argument was default constructed == will always be false
@@ -56,11 +60,11 @@ namespace Opm
 
     private:
         Opm::OilVaporizationEnum m_type = OilVaporizationEnum::UNDEF;
-        double m_vap1;
-        double m_vap2;
-        double m_maxDRSDT;
-        double m_maxDRVDT;
-        bool m_maxDRSDT_allCells;
+        std::vector<double> m_vap1;
+        std::vector<double> m_vap2;
+        std::vector<double> m_maxDRSDT;
+        std::vector<bool> m_maxDRSDT_allCells;
+        std::vector<double> m_maxDRVDT;
     };
 }
 #endif // DRSDT_H

opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp

@@ -40,31 +40,62 @@
 #include <opm/parser/eclipse/EclipseState/Schedule/VFPInjTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/WellTestConfig.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/Action/Actions.hpp>
 
 namespace Opm
 {
 
+    class Actions;
     class Deck;
     class DeckKeyword;
     class DeckRecord;
     class EclipseGrid;
     class Eclipse3DProperties;
+    class EclipseState;
+    class Runspec;
     class SCHEDULESection;
+    class SummaryState;
     class TimeMap;
     class UnitSystem;
-    class EclipseState;
+    class ErrorGuard;
+    class WListManager;
+    class UDQ;
 
     class Schedule {
     public:
         Schedule(const Deck& deck,
                  const EclipseGrid& grid,
                  const Eclipse3DProperties& eclipseProperties,
-                 const Phases &phases,
-                 const ParseContext& parseContext = ParseContext());
+                 const Runspec &runspec,
+                 const ParseContext& parseContext,
+                 ErrorGuard& errors);
+
+        template<typename T>
+        Schedule(const Deck& deck,
+                 const EclipseGrid& grid,
+                 const Eclipse3DProperties& eclipseProperties,
+                 const Runspec &runspec,
+                 const ParseContext& parseContext,
+                 T&& errors);
+
+        Schedule(const Deck& deck,
+                 const EclipseGrid& grid,
+                 const Eclipse3DProperties& eclipseProperties,
+                 const Runspec &runspec);
 
         Schedule(const Deck& deck,
                  const EclipseState& es,
-                 const ParseContext& parseContext = ParseContext());
+                 const ParseContext& parseContext,
+                 ErrorGuard& errors);
+
+        template <typename T>
+        Schedule(const Deck& deck,
+                 const EclipseState& es,
+                 const ParseContext& parseContext,
+                 T&& errors);
+
+        Schedule(const Deck& deck,
+                 const EclipseState& es);
 
         /*
          * If the input deck does not specify a start time, Eclipse's 1. Jan
@@ -73,7 +104,9 @@ namespace Opm
         time_t getStartTime() const;
         time_t posixStartTime() const;
         time_t posixEndTime() const;
-
+        time_t simTime(size_t timeStep) const;
+        double seconds(size_t timeStep) const;
+        double stepLength(size_t timeStep) const;
 
         const TimeMap& getTimeMap() const;
 
@@ -95,20 +128,29 @@ namespace Opm
           is an inefficient way to get all the wells defined at time
           't'.
         */
+        //std::vector< const Group& > getChildGroups(const std::string& group_name, size_t timeStep) const;
+        std::vector< const Group* > getChildGroups(const std::string& group_name, size_t timeStep) const;
         std::vector< const Well* > getWells(const std::string& group, size_t timeStep) const;
+        std::vector< const Well* > getChildWells(const std::string& group_name, size_t timeStep) const;
         std::vector< const Well* > getWellsMatching( const std::string& ) const;
         const OilVaporizationProperties& getOilVaporizationProperties(size_t timestep) const;
 
         const WellTestConfig& wtestConfig(size_t timestep) const;
+        const WListManager& getWListManager(size_t timeStep) const;
+        const UDQ& getUDQConfig(size_t timeStep) const;
+        const Actions& actions() const;
+        void evalAction(const SummaryState& summary_state, size_t timeStep);
 
         const GroupTree& getGroupTree(size_t t) const;
         size_t numGroups() const;
+        size_t numGroups(size_t timeStep) const;
         bool hasGroup(const std::string& groupName) const;
         const Group& getGroup(const std::string& groupName) const;
         std::vector< const Group* > getGroups() const;
+        std::vector< const Group* > getGroups(size_t timeStep) const;
         const Tuning& getTuning() const;
         const MessageLimits& getMessageLimits() const;
-        void invalidNamePattern (const std::string& namePattern, const ParseContext& parseContext, const DeckKeyword& keyword) const;
+        void invalidNamePattern (const std::string& namePattern, const ParseContext& parseContext, ErrorGuard& errors, const DeckKeyword& keyword) const;
 
         const Events& getEvents() const;
         const Deck& getModifierDeck(size_t timeStep) const;
@@ -122,7 +164,9 @@ namespace Opm
           active. Will scan through all wells and all timesteps.
         */
         void filterConnections(const EclipseGrid& grid);
+        size_t size() const;
 
+        void applyAction(size_t reportStep, const ActionX& action, const std::vector<std::string>& matching_wells);
     private:
         TimeMap m_timeMap;
         OrderedMap< Well > m_wells;
@@ -133,57 +177,67 @@ namespace Opm
         DynamicVector< Deck > m_modifierDeck;
         Tuning m_tuning;
         MessageLimits m_messageLimits;
-        Phases m_phases;
+        Runspec m_runspec;
         std::map<int, DynamicState<std::shared_ptr<VFPProdTable>>> vfpprod_tables;
         std::map<int, DynamicState<std::shared_ptr<VFPInjTable>>> vfpinj_tables;
         DynamicState<std::shared_ptr<WellTestConfig>> wtest_config;
+        DynamicState<std::shared_ptr<WListManager>> wlist_manager;
+        DynamicState<std::shared_ptr<UDQ>> udq_config;
 
         WellProducer::ControlModeEnum m_controlModeWHISTCTL;
+        Actions m_actions;
 
-        std::vector< Well* > getWells(const std::string& wellNamePattern);
+        std::vector< Well* > getWells(const std::string& wellNamePattern, const std::vector<std::string>& matching_wells = {});
         std::vector< Group* > getGroups(const std::string& groupNamePattern);
 
         void updateWellStatus( Well& well, size_t reportStep , WellCommon::StatusEnum status);
         void addWellToGroup( Group& newGroup , Well& well , size_t timeStep);
-        void iterateScheduleSection(const ParseContext& parseContext ,  const SCHEDULESection& , const EclipseGrid& grid,
+        void iterateScheduleSection(const ParseContext& parseContext ,  ErrorGuard& errors, const SCHEDULESection& , const EclipseGrid& grid,
                                     const Eclipse3DProperties& eclipseProperties);
         bool handleGroupFromWELSPECS(const std::string& groupName, GroupTree& newTree) const;
         void addGroup(const std::string& groupName , size_t timeStep);
         void addWell(const std::string& wellName, const DeckRecord& record, size_t timeStep, WellCompletion::CompletionOrderEnum wellCompletionOrder);
-        void handleCOMPORD(const ParseContext& parseContext, const DeckKeyword& compordKeyword, size_t currentStep);
+        void handleUDQ(const DeckKeyword& keyword, size_t currentStep);
+        void handleWLIST(const DeckKeyword& keyword, size_t currentStep);
+        void handleCOMPORD(const ParseContext& parseContext, ErrorGuard& errors, const DeckKeyword& compordKeyword, size_t currentStep);
         void handleWELSPECS( const SCHEDULESection&, size_t, size_t  );
-        void handleWCONProducer( const DeckKeyword& keyword, size_t currentStep, bool isPredictionMode,  const ParseContext& parseContext);
-        void handleWCONHIST( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWCONPROD( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
+        void handleWCONProducer( const DeckKeyword& keyword, size_t currentStep, bool isPredictionMode,  const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWCONHIST( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWCONPROD( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
         void handleWGRUPCON( const DeckKeyword& keyword, size_t currentStep);
-        void handleCOMPDAT( const DeckKeyword& keyword,  size_t currentStep, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties, const ParseContext& parseContext);
+        void handleCOMPDAT( const DeckKeyword& keyword,  size_t currentStep, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties, const ParseContext& parseContext, ErrorGuard& errors);
         void handleCOMPLUMP( const DeckKeyword& keyword,  size_t currentStep );
         void handleWELSEGS( const DeckKeyword& keyword, size_t currentStep);
-        void handleCOMPSEGS( const DeckKeyword& keyword, size_t currentStep);
-        void handleWCONINJE( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWPOLYMER( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWSOLVENT( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWTEMP( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWINJTEMP( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWCONINJH( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWELOPEN( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext );
-        void handleWELTARG( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleGCONINJE( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleGCONPROD( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleGEFAC( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWEFAC( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
+        void handleCOMPSEGS( const DeckKeyword& keyword, size_t currentStep, const EclipseGrid& grid);
+        void handleWCONINJE( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWPOLYMER( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWSOLVENT( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWTRACER( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWTEMP( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWPMITAB( const DeckKeyword& keyword,  const size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWSKPTAB( const DeckKeyword& keyword,  const size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWINJTEMP( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWCONINJH( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWELOPEN( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors, const std::vector<std::string>& matching_wells = {});
+        void handleWELTARG( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleGCONINJE( const SCHEDULESection&,  const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleGCONPROD( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleGEFAC( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWEFAC( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
         void handleTUNING( const DeckKeyword& keyword, size_t currentStep);
         void handleGRUPTREE( const DeckKeyword& keyword, size_t currentStep);
         void handleGRUPNET( const DeckKeyword& keyword, size_t currentStep);
         void handleWRFT( const DeckKeyword& keyword, size_t currentStep);
-        void handleWTEST( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
+        void handleWTEST( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
         void handleWRFTPLT( const DeckKeyword& keyword, size_t currentStep);
         void handleWPIMULT( const DeckKeyword& keyword, size_t currentStep);
         void handleDRSDT( const DeckKeyword& keyword, size_t currentStep);
         void handleDRVDT( const DeckKeyword& keyword, size_t currentStep);
+        void handleDRSDTR( const DeckKeyword& keyword, size_t currentStep);
+        void handleDRVDTR( const DeckKeyword& keyword, size_t currentStep);
         void handleVAPPARS( const DeckKeyword& keyword, size_t currentStep);
-        void handleWECON( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext);
-        void handleWHISTCTL(const ParseContext& parseContext, const DeckKeyword& keyword);
+        void handleWECON( const DeckKeyword& keyword, size_t currentStep, const ParseContext& parseContext, ErrorGuard& errors);
+        void handleWHISTCTL(const ParseContext& parseContext, ErrorGuard& errors, const DeckKeyword& keyword);
         void handleMESSAGES(const DeckKeyword& keyword, size_t currentStep);
         void handleVFPPROD(const DeckKeyword& vfpprodKeyword, const UnitSystem& unit_system, size_t currentStep);
         void handleVFPINJ(const DeckKeyword& vfpprodKeyword, const UnitSystem& unit_system, size_t currentStep);
@@ -193,7 +247,7 @@ namespace Opm
                            const SCHEDULESection& section,
                            size_t keywordIdx,
                            const DeckKeyword& keyword,
-                           const ParseContext& parseContext,
+                           const ParseContext& parseContext, ErrorGuard& errors,
                            const EclipseGrid& grid,
                            const Eclipse3DProperties& eclipseProperties,
                            const UnitSystem& unit_system,

opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp

@@ -230,8 +230,7 @@ namespace Opm {
     enum OilVaporizationEnum{
         UNDEF = 0,
         VAPPARS = 1,
-        DRSDT = 2,
-        DRVDT = 3
+        DRDT = 2 // DRSDT or DRVDT
     };
 
 

opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp

@@ -0,0 +1,88 @@
+/*
+  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/>.
+*/
+
+#ifndef SUMMARY_STATE_H
+#define SUMMARY_STATE_H
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+#include <ert/ecl/smspec_node.hpp>
+
+namespace Opm{
+
+
+/*
+  The purpose of this class is to serve as a small container object for
+  computed, ready to use summary values. The values will typically be used by
+  the UDQ, WTEST and ACTIONX calculations. Observe that all value *have been
+  converted to the correct output units*.
+
+  The main key used to access the content of this container is the eclipse style
+  colon separated string - i.e. 'WWCT:OPX' to get the watercut in well 'OPX'.
+  The main usage of the SummaryState class is a temporary holding ground while
+  assembling data for the summary output, but it is also used as a context
+  object when evaulating the condition in ACTIONX keywords. For that reason some
+  of the data is duplicated both in the general structure and a specialized
+  structure:
+
+      SummaryState st;
+
+      st.add_well_var("OPX", "WWCT", 0.75);
+      st.add("WGOR:OPY", 120);
+
+      // The WWCT:OPX key has been added with the specialized add_well_var()
+      // method and this data is available both with the general
+      // st.has("WWCT:OPX") and the specialized st.has_well_var("OPX", "WWCT");
+      st.has("WWCT:OPX") => True
+      st.has_well_var("OPX", "WWCT") => True
+
+
+      // The WGOR:OPY key is added with the general add("WGOR:OPY") and is *not*
+      // accessible through the specialized st.has_well_var("OPY", "WGOR").
+      st.has("WGOR:OPY") => True
+      st.has_well_var("OPY", "WGOR") => False
+*/
+
+class SummaryState {
+public:
+    typedef std::unordered_map<std::string, double>::const_iterator const_iterator;
+
+    double get(const std::string&) const;
+    bool has(const std::string& key) const;
+    void add(const std::string& key, double value);
+    void add(const ecl::smspec_node& node, double value);
+
+    void add_well_var(const std::string& well, const std::string& var, double value);
+    bool has_well_var(const std::string& well, const std::string& var) const;
+    double get_well_var(const std::string& well, const std::string& var) const;
+
+    std::vector<std::string> wells(const std::string& var) const;
+    const_iterator begin() const;
+    const_iterator end() const;
+private:
+    std::unordered_map<std::string,double> values;
+
+    // The first key is the variable and the second key is the well.
+    std::unordered_map<std::string, std::unordered_map<std::string, double>> well_values;
+};
+
+}
+#endif

opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp

@@ -44,6 +44,7 @@ namespace Opm {
         size_t last() const;
         size_t numTimesteps() const;
         double getTotalTime() const;
+        double seconds(size_t timeStep) const;
 
         std::time_t operator[] (size_t index) const;
         /// Return the date and time where a given time step starts.
@@ -65,8 +66,8 @@ namespace Opm {
         static std::time_t forward(std::time_t t0, int64_t seconds);
         static std::time_t mkdate(int year, int month, int day);
         static std::time_t mkdatetime(int year, int month, int day, int hour, int minute, int second);
-    private:
         static const std::map<std::string, int>& eclipseMonthIndices();
+    private:
 
         std::vector<std::time_t> m_timeList;
 

opm/parser/eclipse/EclipseState/Schedule/UDQ.hpp

@@ -21,7 +21,9 @@
 #ifndef UDQState_HPP_
 #define UDQState_HPP_
 
-#include <opm/parser/eclipse/EclipseState/UDQConfig.hpp>
+#include <unordered_map>
+#include <string>
+
 #include <opm/parser/eclipse/EclipseState/Schedule/UDQExpression.hpp>
 
 
@@ -29,10 +31,13 @@ namespace Opm {
 
     class UDQ{
     public:
-        UDQ(const UDQConfig& config, const Deck& deck);
+        void add_record(const DeckRecord& record);
         const std::vector<UDQExpression>& expressions() const noexcept;
+        const std::string& unit(const std::string& key) const;
+        void assign_unit(const std::string& keyword, const std::string& unit);
     private:
         std::vector<UDQExpression> m_expressions;
+        std::unordered_map<std::string, std::string> units;
     };
 }
 

opm/parser/eclipse/EclipseState/Schedule/UDQExpression.hpp

@@ -36,9 +36,12 @@ namespace Opm {
         UDQExpression(const std::string& action, const std::string& keyword, const std::vector<std::string>& data);
         explicit UDQExpression(const DeckRecord& expression);
         const std::vector<std::string>& tokens() const;
+        UDQAction action() const;
+        const std::string& keyword() const;
+        static UDQAction actionString2Enum(const std::string& action_string);
     private:
-        UDQAction action;
-        std::string keyword;
+        UDQAction m_action;
+        std::string m_keyword;
         std::vector<std::string> data;
     };
 }

opm/parser/eclipse/EclipseState/Schedule/VFPProdTable.hpp

@@ -182,9 +182,6 @@ private:
     static void convertGFRToSI(const GFR_TYPE& type,
                                std::vector<double>& values,
                                const UnitSystem& unit_system);
-    static void convertALQToSI(const ALQ_TYPE& type,
-                               std::vector<double>& values,
-                               const UnitSystem& unit_system);
 };
 
 

opm/parser/eclipse/EclipseState/Schedule/WList.hpp

@@ -0,0 +1,41 @@
+/*
+  Copyright 2019 Equinor 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 <cstddef>
+#include <unordered_set>
+#include <vector>
+#include <string>
+
+namespace Opm {
+
+class WList {
+public:
+    using storage = std::unordered_set<std::string>;
+    std::size_t size() const;
+    void add(const std::string& well);
+    void del(const std::string& well);
+    bool has(const std::string& well) const;
+
+    std::vector<std::string> wells() const;
+    storage::const_iterator begin() const;
+    storage::const_iterator end() const;
+private:
+    storage well_list;
+};
+
+}

opm/parser/eclipse/EclipseState/Schedule/WListManager.hpp

@@ -0,0 +1,39 @@
+/*
+  Copyright 2019 Equinor 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 <cstddef>
+#include <map>
+#include <vector>
+#include <string>
+
+namespace Opm {
+
+class WList;
+
+class WListManager {
+public:
+    bool hasList(const std::string&) const;
+    WList& getList(const std::string& name);
+    const WList& getList(const std::string& name) const;
+    WList& newList(const std::string& name);
+    void delWell(const std::string& well);
+private:
+    std::map<std::string, WList> wlists;
+};
+
+}

opm/parser/eclipse/EclipseState/Schedule/Well.hpp

@@ -32,9 +32,11 @@
 #include <opm/parser/eclipse/EclipseState/Schedule/WellEconProductionLimits.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/WellTracerProperties.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/MSW/WellSegments.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
+#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
 
 namespace Opm {
 
@@ -49,13 +51,15 @@ namespace Opm {
 
     class Well {
     public:
-        Well(const std::string& name, int headI,
-             int headJ, double refDepth, Phase preferredPhase,
+        Well(const std::string& name, const size_t& seqIndex, int headI,
+             int headJ, double refDepth, double drainageRadius, Phase preferredPhase,
              const TimeMap& timeMap, size_t creationTimeStep,
              WellCompletion::CompletionOrderEnum completionOrdering = WellCompletion::TRACK,
              bool allowCrossFlow = true, bool automaticShutIn = true);
         const std::string& name() const;
-
+	const size_t& seqIndex() const;
+	std::size_t getTotNoConn() const;
+	void setTotNoConn(std::size_t noConn);
         bool hasBeenDefined(size_t timeStep) const;
         const std::string getGroupName(size_t timeStep) const;
         void setGroupName(size_t timeStep , const std::string& groupName);
@@ -73,6 +77,9 @@ namespace Opm {
         double getRefDepth() const;
         double getRefDepth( size_t timestep ) const;
         void setRefDepth( size_t timestep, double );
+        double getDrainageRadius( size_t timestep ) const;
+        void setDrainageRadius( size_t timestep, double );
+
         Phase getPreferredPhase() const;
 
         bool isAvailableForGroupControl(size_t timeStep) const;
@@ -144,6 +151,9 @@ namespace Opm {
         WellPolymerProperties          getPolymerPropertiesCopy(size_t timeStep) const;
         const WellPolymerProperties&   getPolymerProperties(size_t timeStep) const;
 
+        bool                           setTracerProperties(size_t timeStep , const WellTracerProperties& properties);
+        const WellTracerProperties&    getTracerProperties(size_t timeStep) const;
+
         bool                           setSolventFraction(size_t timeStep , const double fraction);
         const double&                  getSolventFraction(size_t timeStep) const;
 
@@ -184,7 +194,7 @@ namespace Opm {
         bool hasEvent(uint64_t eventMask, size_t reportStep) const;
         void handleCOMPLUMP(const DeckRecord& record, size_t time_step);
         void handleCOMPDAT(size_t time_step, const DeckRecord& record, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties);
-        void handleCOMPSEGS(const DeckKeyword& keyword, size_t time_step);
+        void handleCOMPSEGS(const DeckKeyword& keyword, const EclipseGrid& grid, size_t time_step);
         void handleWELOPEN(const DeckRecord& record, size_t time_step, WellCompletion::StateEnum status);
         void handleWPIMULT(const DeckRecord& record, size_t time_step);
         void handleWELSEGS(const DeckKeyword& keyword, size_t time_step);
@@ -198,7 +208,9 @@ namespace Opm {
     private:
         size_t m_creationTimeStep;
         std::string m_name;
-
+	std::size_t m_seqIndex;
+	std::size_t m_totNoConn=0;
+	
         DynamicState< WellCommon::StatusEnum > m_status;
 
         DynamicState< int > m_isAvailableForGroupControl;
@@ -214,6 +226,7 @@ namespace Opm {
         DynamicState< WellPolymerProperties > m_polymerProperties;
         DynamicState< WellEconProductionLimits > m_econproductionlimits;
         DynamicState< double > m_solventFraction;
+        DynamicState< WellTracerProperties > m_tracerProperties;
         DynamicState< std::string > m_groupName;
         DynamicState< int > m_rft;
         DynamicState< int > m_plt;
@@ -221,6 +234,7 @@ namespace Opm {
         DynamicState< int > m_headI;
         DynamicState< int > m_headJ;
         DynamicState< double > m_refDepth;
+        DynamicState< double > m_drainageRadius;
         Phase m_preferredPhase;
 
         WellCompletion::CompletionOrderEnum m_comporder;

opm/parser/eclipse/EclipseState/Schedule/WellConnections.hpp

@@ -35,24 +35,33 @@ namespace Opm {
         void addConnection(int i, int j , int k ,
                            double depth,
                            WellCompletion::StateEnum state ,
-                           const Value<double>& connectionTransmissibilityFactor,
-                           const Value<double>& diameter,
-                           const Value<double>& skinFactor,
-                           const Value<double>& Kh,
+                           double CF,
+                           double Kh,
+                           double rw,
+                           double r0,
+                           double skin_factor,
                            const int satTableId,
-                           const WellCompletion::DirectionEnum direction = WellCompletion::DirectionEnum::Z);
-        void loadCOMPDAT(const DeckRecord& record, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties);
+                           const WellCompletion::DirectionEnum direction = WellCompletion::DirectionEnum::Z,
+                           const std::size_t seqIndex = 0,
+                           const double segDistStart= 0.0,
+                           const double segDistEnd= 0.0,
+                           const bool defaultSatTabId = true);
+        void loadCOMPDAT(const DeckRecord& record, const EclipseGrid& grid, const Eclipse3DProperties& eclipseProperties, std::size_t& totNC);
 
         using const_iterator = std::vector< Connection >::const_iterator;
 
         void add( Connection );
         size_t size() const;
+        const Connection& operator[](size_t index) const;
         const Connection& get(size_t index) const;
         const Connection& getFromIJK(const int i, const int j, const int k) const;
         Connection& getFromIJK(const int i, const int j, const int k);
 
         const_iterator begin() const { return this->m_connections.begin(); }
         const_iterator end() const { return this->m_connections.end(); }
+        
+        std::size_t totNoConn() const { return this->m_connections.size(); }
+        
         void filter(const EclipseGrid& grid);
         bool allConnectionsShut() const;
         /// Order connections irrespective of input order.
@@ -77,16 +86,22 @@ namespace Opm {
                            int complnum,
                            double depth,
                            WellCompletion::StateEnum state ,
-                           const Value<double>& connectionTransmissibilityFactor,
-                           const Value<double>& diameter,
-                           const Value<double>& skinFactor,
-                           const Value<double>& Kh,
+                           double CF,
+                           double Kh,
+                           double rw,
+                           double r0,
+                           double skin_factor,
                            const int satTableId,
-                           const WellCompletion::DirectionEnum direction = WellCompletion::DirectionEnum::Z);
+                           const WellCompletion::DirectionEnum direction = WellCompletion::DirectionEnum::Z,
+                           const std::size_t seqIndex = 0,
+                           const double segDistStart= 0.0,
+                           const double segDistEnd= 0.0,
+                           const bool defaultSatTabId = true);
 
-        std::vector< Connection > m_connections;
         size_t findClosestConnection(int oi, int oj, double oz, size_t start_pos);
+
         int headI, headJ;
+        std::vector< Connection > m_connections;
     };
 }
 

opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp

@@ -60,6 +60,10 @@ namespace Opm {
             if ((injectionControls & controlModeArg) == 0)
                 injectionControls += controlModeArg;
         }
+
+        void resetDefaultHistoricalBHPLimit();
+
+        void setBHPLimit(const double limit);
     };
 
     std::ostream& operator<<( std::ostream&, const WellInjectionProperties& );

opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.hpp

@@ -26,6 +26,9 @@ namespace Opm {
     struct WellPolymerProperties {
         double m_polymerConcentration;
         double m_saltConcentration;
+        int m_plymwinjtable;
+        int m_skprwattable;
+        int m_skprpolytable;
 
         bool operator==(const WellPolymerProperties& other) const;
         bool operator!=(const WellPolymerProperties& other) const;

opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp

@@ -57,7 +57,8 @@ namespace Opm {
 
         static WellProductionProperties history(const WellProductionProperties& prevProperties,
                                                 const DeckRecord& record,
-                                                const WellProducer::ControlModeEnum controlModeWHISTCL);
+                                                const WellProducer::ControlModeEnum controlModeWHISTCL,
+                                                const bool switching_from_injector);
 
         static WellProductionProperties prediction( const DeckRecord& record, bool addGroupProductionControl );
 
@@ -82,6 +83,12 @@ namespace Opm {
         int m_productionControls = 0;
 
         WellProductionProperties(const DeckRecord& record);
+
+        void resetDefaultBHPLimit();
+
+        void setBHPLimit(const double limit);
+
+        double getBHPLimit() const;
     };
 
     std::ostream& operator<<( std::ostream&, const WellProductionProperties& );

opm/parser/eclipse/EclipseState/Schedule/WellTestState.hpp

@@ -105,6 +105,11 @@ public:
     size_t sizeWells() const;
     size_t sizeCompletions() const;
 
+    /*
+      Return the last tested time for the well, or throw if no such well.
+    */
+    double lastTestTime(const std::string& well_name) const;
+
 private:
     std::vector<ClosedWell> wells;
     std::vector<ClosedCompletion> completions;

opm/parser/eclipse/EclipseState/Schedule/WellTracerProperties.hpp

@@ -0,0 +1,45 @@
+/*
+  Copyright 2018 NORCE.
+
+  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 WELLTRACERPROPERTIES_HPP_HEADER_INCLUDED
+#define WELLTRACERPROPERTIES_HPP_HEADER_INCLUDED
+#include <vector>
+#include <string>
+#include <map>
+
+namespace Opm {
+
+    class WellTracerProperties {
+
+    public:
+        WellTracerProperties();
+
+        void setConcentration(const std::string& name, const double& concentration);
+        double getConcentration(const std::string& name) const;
+
+        bool operator==(const WellTracerProperties& other) const;
+        bool operator!=(const WellTracerProperties& other) const;
+
+    private:
+        std::map< std::string, double > m_tracerConcentrations;
+    };
+
+}
+
+#endif

opm/parser/eclipse/EclipseState/SimulationConfig/SimulationConfig.hpp

@@ -40,12 +40,14 @@ namespace Opm {
         bool useCPR() const;
         bool hasDISGAS() const;
         bool hasVAPOIL() const;
+        bool isThermal() const;
 
     private:
         ThresholdPressure m_ThresholdPressure;
         bool m_useCPR;
         bool m_DISGAS;
         bool m_VAPOIL;
+        bool m_isThermal;
     };
 
 } //namespace Opm

opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp

@@ -24,24 +24,109 @@
 #include <vector>
 #include <set>
 
-#include <ert/ecl/Smspec.hpp>
+#include <ert/ecl/smspec_node.hpp>
 
 namespace Opm {
 
+    /*
+      Very small utility class to get value semantics on the smspec_node
+      pointers. This should die as soon as the smspec_node class proper gets
+      value semantics.
+    */
+
+    class SummaryNode {
+    public:
+        SummaryNode(const std::string& keyword) :
+            ecl_node(0, keyword.c_str(), "UNIT", 0.0)
+        {}
+
+
+        SummaryNode(const std::string& keyword, const std::string& wgname) :
+            ecl_node(0, keyword.c_str(), wgname.c_str(), "UNIT", 0.0, ":")
+        {}
+
+        SummaryNode(const std::string& keyword, const std::string& wgname, int num) :
+            ecl_node(0, keyword.c_str(), wgname.c_str(), num, "UNIT", 0.0, ":")
+        {}
+
+        SummaryNode(const std::string& keyword, int num) :
+            ecl_node(0, keyword.c_str(), num, "UNIT", 0, ":")
+        {}
+
+        SummaryNode(const std::string& keyword, int num, const int grid_dims[3]) :
+            ecl_node(0, keyword.c_str(), num, "UNIT", grid_dims, 0, ":")
+        {}
+
+        SummaryNode(const std::string& keyword, const std::string& wgname, int num, const int grid_dims[3]) :
+            ecl_node(0, keyword.c_str(), wgname.c_str(), num, "UNIT", grid_dims, 0, ":")
+        {}
+
+        std::string wgname() const {
+            const char * c_ptr = this->ecl_node.get_wgname();
+            if (c_ptr)
+                return std::string(c_ptr);
+            else
+                return "";
+        }
+
+        std::string keyword() const {
+            return this->ecl_node.get_keyword();
+        }
+
+        std::string gen_key() const {
+            return this->ecl_node.get_gen_key1();
+        }
+
+        int num() const {
+            return this->ecl_node.get_num();
+        }
+
+        ecl_smspec_var_type type() const {
+            return this->ecl_node.get_var_type();
+        }
+
+        int cmp(const SummaryNode& other) const {
+            return this->ecl_node.cmp( other.ecl_node );
+        }
+
+    private:
+        ecl::smspec_node ecl_node;
+    };
+
+
     class Deck;
     class TableManager;
     class EclipseState;
     class ParserKeyword;
     class Schedule;
+    class ErrorGuard;
     class ParseContext;
     class GridDims;
 
     class SummaryConfig {
         public:
-            typedef std::vector< ERT::smspec_node >::const_iterator const_iterator;
+            typedef SummaryNode keyword_type;
+            typedef std::vector< keyword_type > keyword_list;
+            typedef keyword_list::const_iterator const_iterator;
+
+            SummaryConfig( const Deck&,
+                           const Schedule&,
+                           const TableManager&,
+                           const ParseContext&,
+                           ErrorGuard&);
+
+            template <typename T>
+            SummaryConfig( const Deck&,
+                           const Schedule&,
+                           const TableManager&,
+                           const ParseContext&,
+                           T&&);
+
+            SummaryConfig( const Deck&,
+                           const Schedule&,
+                           const TableManager&);
+
 
-            SummaryConfig( const Deck&, const Schedule&,
-                           const TableManager&, const ParseContext&);
 
             const_iterator begin() const;
             const_iterator end() const;
@@ -73,6 +158,7 @@ namespace Opm {
                            const Schedule& schedule,
                            const TableManager& tables,
                            const ParseContext& parseContext,
+                           ErrorGuard& errors,
                            const GridDims& dims);
 
             /*
@@ -80,7 +166,7 @@ namespace Opm {
               part, e.g. "WWCT", and not the qualification with
               well/group name or a numerical value.
             */
-            std::vector< ERT::smspec_node > keywords;
+            keyword_list keywords;
             std::set<std::string> short_keywords;
             std::set<std::string> summary_keywords;
     };

opm/parser/eclipse/EclipseState/Tables/PlymwinjTable.hpp

@@ -0,0 +1,38 @@
+/*
+  Copyright (C) 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/>.
+ */
+
+#ifndef OPM_PARSER_PLYMWINJ_TABLE_HPP
+#define OPM_PARSER_PLYMWINJ_TABLE_HPP
+
+#include <opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp>
+namespace Opm {
+
+    class DeckKeyword;
+
+    class PlymwinjTable : public PolyInjTable {
+    public:
+
+        explicit PlymwinjTable(const DeckKeyword& table);
+
+        const std::vector<std::vector<double>>& getMoleWeights() const;
+    };
+
+}
+
+#endif //OPM_PARSER_PLYMWINJ_TABLE_HPP

opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp

@@ -0,0 +1,67 @@
+/*
+  Copyright (C) 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/>.
+ */
+
+#ifndef OPM_PARSER_POLY_INJ_TABLE_HPP
+#define OPM_PARSER_POLY_INJ_TABLE_HPP
+
+
+/* This class is introduced for the following keywords related to polymer injectivity study.
+ * PLYMWINJ, SKPRWAT, SKPRPOLY .
+ * These keywords share very similar structure with small difference.
+ *
+ * KEYWORD
+ *  1 / --table number
+ *  0  20  30 / -- water throughputs
+ *  0 0.1 0.2 0.3 / -- water velocities
+ *  -- the rest is the table data,
+ *  -- each row corresponds to one value in throughputs
+ *  -- each column corresponds to one value in water velocities
+ *  20 19 18 17 /
+ *  20 18 17 16 /
+ *  20 17 16 15 /
+ */
+
+#include <vector>
+
+namespace Opm {
+
+    class PolyInjTable {
+    public:
+
+        int getTableNumber() const;
+
+        const std::vector<double>& getThroughputs() const;
+        const std::vector<double>& getVelocities() const;
+        const std::vector<std::vector<double>>& getTableData() const;
+
+    protected:
+        std::vector<double> m_throughputs;
+        std::vector<double> m_velocities;
+
+        // TODO: maybe not needed, since this is also stored in the std::map
+        int m_table_number;
+
+        // each vector corresponds to the values corresponds to one value related to one x sampling point
+        // as a result, the number of the vector should be equal to be the size of m_x_points,
+        // the size of each vector should be equal to the size of m_y_points
+        std::vector<std::vector<double> > m_data;
+    };
+}
+
+#endif // OPM_PARSER_POLY_INJ_TABLE_HPP

opm/parser/eclipse/EclipseState/Tables/SkprpolyTable.hpp

@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 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/>.
+ */
+
+#ifndef OPM_PARSER_SKPRPOLY_TABLE_HPP
+#define OPM_PARSER_SKPRPOLY_TABLE_HPP
+
+#include <opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp>
+namespace Opm {
+
+    class DeckKeyword;
+
+    class SkprpolyTable : public PolyInjTable {
+    public:
+
+        explicit SkprpolyTable(const DeckKeyword& table);
+
+        double referenceConcentration() const;
+
+        const std::vector<std::vector<double>>& getSkinPressures() const;
+
+    private:
+        double m_ref_polymer_concentration;
+
+    };
+
+}
+
+#endif //OPM_PARSER_SKPRPOLY_TABLE_HPP