bump packaging versions for 2016.10 final

Revert "[bugfix] since HAVE_DUNE_ISTL is used in opm-grid it should b…

.travis.yml

@@ -8,7 +8,6 @@ addons:
     sources:
       - boost-latest
       - ubuntu-toolchain-r-test
-      - george-edison55-precise-backports
     packages:
       - libboost1.55-all-dev
       - gcc-4.8
@@ -18,14 +17,6 @@ addons:
       - libgmp3-dev
       - libsuitesparse-dev
       - libeigen3-dev
-      - bc
-      - cmake
-      - cmake-data
-
-env:
-  global:
-  - TRAVIS_CI=1
-
 
 before_script:
     - export CXX="g++-4.8" CC="gcc-4.8" FC="gfortran-4.8"

CMakeLists.txt

@@ -12,7 +12,7 @@ endmacro (dir_hook)
 set(OPM_PROJECT_EXTRA_CODE_INSTALLED  "set(OPM_MACROS_ROOT ${CMAKE_INSTALL_PREFIX}/share/opm)
                                        list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)")
 
-set(OPM_PROJECT_EXTRA_CODE_INTREE  "set(OPM_MACROS_ROOT ${OPM_MACROS_ROOT})
+set(OPM_PROJECT_EXTRA_CODE_INTREE  "set(OPM_MACROS_ROOT ${OPM_COMMON_ROOT})
                                     list(APPEND CMAKE_MODULE_PATH \${OPM_MACROS_ROOT}/cmake/Modules)")
 
 # project information is in dune.module. Read this file and set variables.

CMakeLists_files.cmake

@@ -54,9 +54,6 @@ list (APPEND PROGRAM_SOURCE_FILES
 list( APPEND PUBLIC_HEADER_FILES
       opm/common/ErrorMacros.hpp
       opm/common/Exceptions.hpp
-      opm/common/ResetLocale.hpp
-      opm/common/Unused.hpp
-      opm/common/Valgrind.hpp
       opm/common/data/SimulationDataContainer.hpp
       opm/common/OpmLog/CounterLog.hpp
       opm/common/OpmLog/EclipsePRTLog.hpp

cmake/Modules/FindCXX11Features.cmake

@@ -33,34 +33,23 @@ include(CheckIncludeFileCXX)
 # macro to only add option once
 include(AddOptions)
 
-# Force CXX Standard cross platfrom for CMakeVersion >=3.1
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-if(NOT CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 11)
-
-
-  if(NOT MSVC)
-    foreach(_flag "14" "11")
-      set(_FLAG "CXX_FLAG_CXX${_flag}")
-      string(TOUPPER ${_FLAG} _FLAG)
-      # try to use compiler flag -std=c++${_flag}
-      CHECK_CXX_ACCEPTS_FLAG("-std=c++${_flag}" ${_FLAG})
-
-      if(${_FLAG})
-        if(CMAKE_VERSION VERSION_LESS 3.1)
-          add_options (CXX ALL_BUILDS "-std=c++${_flag}")
-        endif()
-        set(CXX_STD0X_FLAGS "-std=c++${_flag}")
-        #Use vriables for CMake > 3.1 set the standard with no extensions
-        set(CMAKE_CXX_STANDARD ${_flag})
-        break()
-      endif()
-    endforeach()
-  endif(NOT MSVC)
-endif()
-
 if(CMAKE_VERSION VERSION_LESS 3.1)
+  if(NOT MSVC)
+    # try to use compiler flag -std=c++11
+    CHECK_CXX_ACCEPTS_FLAG("-std=c++11" CXX_FLAG_CXX11)
+    if(CXX_FLAG_CXX11)
+      add_options (CXX ALL_BUILDS "-std=c++11")
+      set(CXX_STD0X_FLAGS "-std=c++11")
+    else()
+      # try to use compiler flag -std=c++0x for older compilers
+      CHECK_CXX_ACCEPTS_FLAG("-std=c++0x" CXX_FLAG_CXX0X)
+      if(CXX_FLAG_CXX0X)
+        add_options (CXX ALL_BUILDS "-std=c++0x")
+        set(CXX_STD0X_FLAGS "-std=c++0x")
+      endif(CXX_FLAG_CXX0X)
+    endif(CXX_FLAG_CXX11)
+  endif(NOT MSVC)
+
   # if we are building with an Apple toolchain in MacOS X,
   # we cannot use the old GCC 4.2 fork, but must use the
   # new runtime library
@@ -69,8 +58,8 @@ if(CMAKE_VERSION VERSION_LESS 3.1)
   if (APPLE AND (_comp_id MATCHES "CLANG"))
     CHECK_CXX_ACCEPTS_FLAG ("-stdlib=libc++" CXX_FLAG_STDLIB_LIBCXX)
     if (CXX_FLAG_STDLIB_LIBCXX)
-      add_options (CXX ALL_BUILDS "-stdlib=libc++")
+          add_options (CXX ALL_BUILDS "-stdlib=libc++")
-      set (CXX_STDLIB_FLAGS "-stdlib=libc++")
+          set (CXX_STDLIB_FLAGS "-stdlib=libc++")
     endif (CXX_FLAG_STDLIB_LIBCXX)
   endif (APPLE AND (_comp_id MATCHES "CLANG"))
 
@@ -80,9 +69,13 @@ if(CMAKE_VERSION VERSION_LESS 3.1)
   else (CXX_STD0X_FLAGS AND CXX_STDLIB_FLAGS)
     set (CXX_SPACE)
   endif (CXX_STD0X_FLAGS AND CXX_STDLIB_FLAGS)
-endif()
+else()
+  if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+  endif()
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  set(CMAKE_CXX_EXTENSIONS OFF)
 
-if(NOT CMAKE_VERSION VERSION_LESS 3.1)
   # Workaround bug in cmake:
   # cxx standard flags are not applied in CheckCXXSourceCompiles
   if (CMAKE_CXX_STANDARD EQUAL 14)
@@ -92,7 +85,6 @@ if(NOT CMAKE_VERSION VERSION_LESS 3.1)
   endif()
 endif()
 
-
 # perform tests
 include(CheckCXXSourceCompiles)
 

cmake/Modules/FindClangCheck.cmake

@@ -1,11 +0,0 @@
-# Find clang-check.
-#
-# This module defines:
-#  CLANGCHECK_PROGRAM, the clang-check executable.
-#  CLANGHCECK_FOUND, If false, do not try to use cppcheck.
-#
-find_program(CLANGCHECK_PROGRAM NAMES clang-check clang-check-3.8)
-
-find_package_handle_standard_args(ClangCheck DEFAULT_MSG CLANGCHECK_PROGRAM)
-
-mark_as_advanced(CLANGCHECK_PROGRAM)

cmake/Modules/FindCppCheck.cmake

@@ -1,11 +0,0 @@
-# Find CppCheck.
-#
-# This module defines:
-#  CPPCHECK_PROGRAM, the cppcheck executable.
-#  CPPCHECK_FOUND, If false, do not try to use cppcheck.
-#
-find_program(CPPCHECK_PROGRAM NAMES cppcheck)
-
-find_package_handle_standard_args(CppCheck DEFAULT_MSG CPPCHECK_PROGRAM)
-
-mark_as_advanced(CPPCHECK_PROGRAM)

cmake/Modules/FindERT.cmake

@@ -33,7 +33,7 @@ endif (ERT_ROOT)
 find_path (ERT_ECL_INCLUDE_DIR
   NAMES "ert/ecl/ecl_util.h"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}/../libecl" "${PROJECT_SOURCE_DIR}/../ert"
+  PATHS "${PROJECT_SOURCE_DIR}/../ert"
   PATH_SUFFIXES "libecl/include/" "include"
   DOC "Path to ERT Eclipse library header files"
   ${_no_default_path}
@@ -41,7 +41,7 @@ find_path (ERT_ECL_INCLUDE_DIR
 find_path (ERT_ECL_WELL_INCLUDE_DIR
   NAMES "ert/ecl_well/well_const.h"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}/../libecl" "${PROJECT_SOURCE_DIR}/../ert"
+  PATHS "${PROJECT_SOURCE_DIR}/../ert"
   PATH_SUFFIXES "libecl_well/include/" "include"
   DOC "Path to ERT Eclipse library header files"
   ${_no_default_path}
@@ -49,7 +49,7 @@ find_path (ERT_ECL_WELL_INCLUDE_DIR
 find_path (ERT_ECLXX_INCLUDE_DIR
   NAMES "ert/ecl/EclKW.hpp"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}/../libecl" "${PROJECT_SOURCE_DIR}/../ert"
+  PATHS "${PROJECT_SOURCE_DIR}/../ert"
   PATH_SUFFIXES "libeclxx/include/" "include"
   DOC "Path to ERT Eclipse C++ library header files"
   ${_no_default_path}
@@ -57,7 +57,7 @@ find_path (ERT_ECLXX_INCLUDE_DIR
 find_path (ERT_UTIL_INCLUDE_DIR
   NAMES "ert/util/stringlist.h"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}/../libecl" "${PROJECT_SOURCE_DIR}/../ert"
+  PATHS "${PROJECT_SOURCE_DIR}/../ert"
   PATH_SUFFIXES "libert_util/include/" "include"
   DOC "Path to ERT Eclipse library header files"
   ${_no_default_path}
@@ -65,7 +65,7 @@ find_path (ERT_UTIL_INCLUDE_DIR
 find_path (ERT_UTILXX_INCLUDE_DIR
   NAMES "ert/util/ert_unique_ptr.hpp"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}/../libecl" "${PROJECT_SOURCE_DIR}/../ert"
+  PATHS "${PROJECT_SOURCE_DIR}/../ert"
   PATH_SUFFIXES "libert_utilxx/include/" "include"
   DOC "Path to ERT Eclipse C++ library header files"
   ${_no_default_path}
@@ -73,7 +73,7 @@ find_path (ERT_UTILXX_INCLUDE_DIR
 find_path (ERT_GEN_INCLUDE_DIR
   NAMES "ert/util/int_vector.h"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}/../libecl" "${PROJECT_SOURCE_DIR}/../ert"
+  PATHS "${PROJECT_SOURCE_DIR}/../ert"
   PATH_SUFFIXES "libert_util/include"
                 "include" "build/libert_util/include" "build/libert_util/include"
   DOC "Path to ERT generated library header files"
@@ -88,10 +88,7 @@ endif (CMAKE_SIZEOF_VOID_P)
 find_library (ERT_LIBRARY_ECL
   NAMES "ecl"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_BINARY_DIR}/../libecl"
+  PATHS "${PROJECT_BINARY_DIR}/../ert"
-        "${PROJECT_SOURCE_DIR}/../libecl/build"
-        "${PROJECT_BINARY_DIR}/../libecl-build"
-        "${PROJECT_BINARY_DIR}/../ert"
         "${PROJECT_SOURCE_DIR}/../ert/build"
         "${PROJECT_BINARY_DIR}/../ert-build"
   PATH_SUFFIXES "lib" "lib/Release" "lib/Debug" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
@@ -101,10 +98,7 @@ find_library (ERT_LIBRARY_ECL
 find_library (ERT_LIBRARY_ECLXX
   NAMES "eclxx"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_BINARY_DIR}/../libecl"
+  PATHS "${PROJECT_BINARY_DIR}/../ert"
-        "${PROJECT_SOURCE_DIR}/../libecl/build"
-        "${PROJECT_BINARY_DIR}/../libecl-build"
-        "${PROJECT_BINARY_DIR}/../ert"
         "${PROJECT_SOURCE_DIR}/../ert/build"
         "${PROJECT_BINARY_DIR}/../ert-build"
   PATH_SUFFIXES "lib" "lib/Release" "lib/Debug" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
@@ -114,10 +108,7 @@ find_library (ERT_LIBRARY_ECLXX
 find_library (ERT_LIBRARY_ECL_WELL
   NAMES "ecl_well"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_BINARY_DIR}/../libecl"
+  PATHS "${PROJECT_BINARY_DIR}/../ert"
-        "${PROJECT_SOURCE_DIR}/../libecl/build"
-        "${PROJECT_BINARY_DIR}/../libecl-build"
-        "${PROJECT_BINARY_DIR}/../ert"
         "${PROJECT_SOURCE_DIR}/../ert/build"
         "${PROJECT_BINARY_DIR}/../ert-build"
   PATH_SUFFIXES "lib" "lib/Release" "lib/Debug" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
@@ -127,10 +118,7 @@ find_library (ERT_LIBRARY_ECL_WELL
 find_library (ERT_LIBRARY_GEOMETRY
   NAMES "ert_geometry"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_BINARY_DIR}/../libecl"
+  PATHS "${PROJECT_BINARY_DIR}/../ert"
-        "${PROJECT_SOURCE_DIR}/../libecl/build"
-        "${PROJECT_BINARY_DIR}/../libecl-build"
-        "${PROJECT_BINARY_DIR}/../ert"
         "${PROJECT_SOURCE_DIR}/../ert/build"
         "${PROJECT_BINARY_DIR}/../ert-build"
   PATH_SUFFIXES "lib" "lib/Release" "lib/Debug" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
@@ -140,10 +128,7 @@ find_library (ERT_LIBRARY_GEOMETRY
 find_library (ERT_LIBRARY_UTIL
   NAMES "ert_util"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_BINARY_DIR}/../libecl"
+  PATHS "${PROJECT_BINARY_DIR}/../ert"
-        "${PROJECT_SOURCE_DIR}/../libecl/build"
-        "${PROJECT_BINARY_DIR}/../libecl-build"
-        "${PROJECT_BINARY_DIR}/../ert"
         "${PROJECT_SOURCE_DIR}/../ert/build"
         "${PROJECT_BINARY_DIR}/../ert-build"
   PATH_SUFFIXES "lib" "lib/Release" "lib/Debug" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
@@ -153,10 +138,7 @@ find_library (ERT_LIBRARY_UTIL
 find_library (ERT_LIBRARY_UTILXX
   NAMES "ert_utilxx"
   HINTS "${ERT_ROOT}"
-  PATHS "${PROJECT_BINARY_DIR}/../libecl"
+  PATHS "${PROJECT_BINARY_DIR}/../ert"
-        "${PROJECT_SOURCE_DIR}/../libecl/build"
-        "${PROJECT_BINARY_DIR}/../libecl-build"
-        "${PROJECT_BINARY_DIR}/../ert"
         "${PROJECT_SOURCE_DIR}/../ert/build"
         "${PROJECT_BINARY_DIR}/../ert-build"
   PATH_SUFFIXES "lib" "lib/Release" "lib/Debug" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
@@ -260,10 +242,9 @@ if (NOT (ERT_INCLUDE_DIR MATCHES "-NOTFOUND" OR ERT_LIBRARIES MATCHES "-NOTFOUND
   set (CMAKE_REQUIRED_INCLUDES ${ERT_INCLUDE_DIR})
   set (CMAKE_REQUIRED_LIBRARIES ${ERT_LIBRARIES})
   check_cxx_source_compiles (
-"#include <ert/ecl/ecl_grid.h>
+"#include <ert/ecl/EclKW.hpp>
 int main ( ) {
-    ecl_grid_type * grid = ecl_grid_alloc_rectangular( 10,10,10,1,1,1, NULL);
+    ERT::EclKW< int > kw( ecl_kw_alloc( \"SATNUM\", 0, ECL_INT_TYPE ) );
-    ecl_grid_free( grid );
     return 0;
 }" HAVE_ERT)
   cmake_pop_check_state ()

cmake/Modules/FindPETSc.cmake

@@ -16,11 +16,6 @@
 
 # find out the size of a pointer. this is required to only search for
 # libraries in the directories relevant for the architecture
-
-if(NOT USE_PETSC)
-  return()
-endif()
-
 if (CMAKE_SIZEOF_VOID_P)
   math (EXPR _BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
 endif (CMAKE_SIZEOF_VOID_P)

cmake/Modules/FindSuperLU.cmake

@@ -15,10 +15,6 @@
 # SUPERLU_LIBRARIES           Name to the SuperLU library.
 #
 
-if(NOT USE_SUPERLU)
-  return()
-endif()
-
 include(CheckIncludeFiles)
 include(CMakePushCheckState)
 include(CheckCSourceCompiles)
@@ -122,19 +118,6 @@ int main(void)
   return 0;
 }"
 SUPERLU_POST_2005_VERSION)
-
-# check whether version is at least 5.0
-CHECK_C_SOURCE_COMPILES("
-typedef int int_t;
-#include <supermatrix.h>
-#include <slu_util.h>
-int main(void)
-{
-  GlobalLU_t glu;
-  return 0;
-}"
-SUPERLU_MIN_VERSION_5)
-
 cmake_pop_check_state()
 
 if(SUPERLU_MIN_VERSION_4_3)
@@ -145,17 +128,6 @@ else()
     "Human readable string containing SuperLU version information.")
 endif()
 
-if(SUPERLU_MIN_VERSION_5)
-  include(UseDuneVer)
-  find_dune_version("dune" "istl")
-  set(DUNE_ISTL_VERSION ${DUNE_ISTL_VERSION_MAJOR}.${DUNE_ISTL_VERSION_MINOR}.${DUNE_ISTL_VERSION_REVISION})
-  if(DUNE_ISTL_VERSION VERSION_LESS 2.5)
-    message(STATUS "SuperLU requested, but version found not compatible with dune-istl ${DUNE_ISTL_VERSION}")
-    set(SUPERLU_LIBRARY "")
-    set(SUPERLU_INCLUDE_DIR "")
-  endif()
-endif()
-
 # behave like a CMake module is supposed to behave
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(

cmake/Modules/FindTinyXML.cmake

@@ -0,0 +1,37 @@
+# - Find TinyXML library
+#
+# Defines the following variables:
+#   TinyXML_INCLUDE_DIRS    Directory of header files
+#   TinyXML_LIBRARIES       Directory of shared object files
+#   TinyXML_DEFINITIONS     Defines that must be set to compile
+
+# Copyright (C) 2012 Uni Research AS
+# This code is licensed under The GNU General Public License v3.0
+
+# use the generic find routine
+include (OpmPackage)
+find_opm_package (
+  # module name
+  "TinyXML"
+
+  # dependencies
+  ""
+  
+  # header to search for
+  "tinyxml.h"
+
+  # library to search for
+  "tinyxml"
+
+  # defines to be added to compilations
+  ""
+
+  # test program
+"#include <tinyxml.h>
+int main (void) {
+  TiXmlDocument doc;
+  return 0;  
+}
+"
+  # config variables
+  "")

cmake/Modules/Findcjson.cmake

@@ -20,8 +20,8 @@ endif (CJSON_ROOT)
 find_path (CJSON_INCLUDE_DIR
   NAMES "cjson/cJSON.h"
   HINTS "${CJSON_ROOT}"
-  PATHS "${PROJECT_SOURCE_DIR}"
+  PATHS "${PROJECT_SOURCE_DIR}" "${PROJECT_SOURCE_DIR}/../opm-parser"
-  PATH_SUFFIXES "include" "external"
+  PATH_SUFFIXES "include" "opm/json"
   DOC "Path to cjson library header files"
   ${_no_default_path} )
 

cmake/Modules/Finddune-grid.cmake

@@ -41,7 +41,7 @@ find_opm_package (
 "#include <dune/grid/onedgrid.hh>
 int main (void) {
   Dune::OneDGrid grid(1, 0., 1.);
-  return grid.size(0);
+  return grid.lbegin<0>(0) == grid.lend<0>(0);
 }
 "
   # config variables

cmake/Modules/Findopm-core.cmake

@@ -21,7 +21,7 @@ find_opm_package (
   "${opm-core_DEPS}"
   
   # header to search for
-  "opm/core/wells.h"
+  "opm/core/grid.h"
 
   # library to search for
   "opmcore"
@@ -30,13 +30,12 @@ find_opm_package (
   ""
 
   # test program
-"
+"#include <opm/core/grid.h>
-#include <opm/core/utility/parameters/ParameterGroup.hpp>
+int main (void) {
-int main()
+  struct UnstructuredGrid *g;
-{
+  g = create_grid_empty ();
-    Opm::ParameterGroup parameters;
+  destroy_grid (g);
-    parameters.insertParameter(\"number\", \"7\");
+  return 0;  
-    return 0;
 }
 "
   # config variables

cmake/Modules/Findopm-data.cmake

@@ -17,8 +17,8 @@ endif()
 if (EXISTS "${_opm_data_root}/norne/NORNE_ATW2013.DATA")
    set( HAVE_OPM_DATA True )
    set( OPM_DATA_ROOT ${_opm_data_root} )
-   message(STATUS "Setting OPM_DATA_ROOT: ${OPM_DATA_ROOT}")
+   message( "-- Setting OPM_DATA_ROOT: ${OPM_DATA_ROOT}")
 else()
    set( HAVE_OPM_DATA False )
-   message(WARNING "opm-data not found - integration tests using opm-data will be skipped.")
+   message( "opm-data not found - integration tests using opm-data will be skipped.")
-endif()
+endif()

cmake/Modules/Findopm-grid.cmake

@@ -20,7 +20,7 @@ find_opm_package (
   "${opm-grid_DEPS}"
   
   # header to search for
-  "dune/grid/cpgrid/GlobalIdMapping.hpp"
+  "dune/grid/CpGrid.hpp"
 
   # library to search for
   "opmgrid"
@@ -29,9 +29,9 @@ find_opm_package (
   "HAVE_OPM_GRID"
 
   # test program
-"#include <dune/grid/cpgrid/GlobalIdMapping.hpp>
+"#include <dune/grid/CpGrid.hpp>
 int main (void) {
-  Dune::cpgrid::GlobalIdMapping g;
+  Dune::CpGrid g;
   return 0;
 }
 "

cmake/Modules/Findopm-output.cmake

@@ -42,3 +42,14 @@ include (UseDynamicBoost)
 #debug_find_vars ("opm-output")
 
 
+if(OPM_OUTPUT_FOUND)
+  get_filename_component(opm-output_PREFIX_DIR ${opm-output_LIBRARY} PATH)
+  find_program(COMPARE_SUMMARY_COMMAND compareSummary
+               PATHS ${opm-output_PREFIX_DIR}/../bin
+                     ${opm-output_PREFIX_DIR}/../../bin)
+  find_program(COMPARE_ECL_COMMAND compareECL
+               PATHS ${opm-output_PREFIX_DIR}/../bin
+                     ${opm-output_PREFIX_DIR}/../../bin)
+
+endif()
+

cmake/Modules/Findopm-parser.cmake

@@ -18,6 +18,13 @@ else ()
   set (OPM_PARSER_QUIET "")
 endif ()
 
+# use lowercase versions of the variables if those are set
+if (opm-parser_ROOT)
+  set (OPM_PARSER_ROOT ${opm-parser_ROOT})
+endif ()
+if (opm_ROOT)
+  set (OPM_ROOT ${opm_ROOT})
+endif ()
 
 # inherit "suite" root if not specifically set for this library
 if ((NOT OPM_PARSER_ROOT) AND OPM_ROOT)
@@ -43,24 +50,120 @@ else ()
     "${PROJECT_BINARY_DIR}/../../opm-parser/${BUILD_DIR_SUFFIX}")
 endif ()
 
+# use this header as signature
+find_path (OPM_PARSER_INCLUDE_DIR
+  NAMES "opm/parser/eclipse/Parser/Parser.hpp"
+  HINTS "${OPM_PARSER_ROOT}"
+  PATHS ${_opm_parser_source}
+  PATH_SUFFIXES "include"
+  DOC "Path to OPM parser header files"
+  ${_no_default_path} )
 
-find_package(opm-parser CONFIG HINTS ${_opm_parser_build})
+find_path (OPM_PARSER_GEN_INCLUDE_DIR
-if (opm-parser_FOUND)
+  NAMES "opm/parser/eclipse/Parser/ParserKeywords.hpp"
-    find_package(ecl REQUIRED)
+  HINTS "${OPM_PARSER_ROOT}"
-    find_package(Boost 1.44.0
+  PATHS ${_opm_parser_build}
-                 COMPONENTS regex filesystem system date_time
+  PATH_SUFFIXES "generated-source/include" "include"
-                 REQUIRED)
+  DOC "Path to OPM parser generated header files"
-    set(HAVE_OPM_PARSER 1)
+  ${_no_default_path} )
-    # setting HAVE_ERT is a mega hack here, but some downstreams require it.
-    # Eventually projets should move on to properly handle dependencies and
-    # configurations, and Findopm-parser be deprecated
-    set(HAVE_ERT 1)
-    set(opm-parser_CONFIG_VARS HAVE_OPM_PARSER HAVE_REGEX HAVE_ERT)
-    set(opm-parser_LIBRARIES opmparser)
 
-    find_package_handle_standard_args(opm-parser
+
-        DEFAULT_MSG
+# backup: if we didn't find any headers there, but a CMakeCache.txt,
-        opm-parser_LIBRARIES HAVE_OPM_PARSER HAVE_ERT
+# then it is probably a build directory; read the CMake cache of
-    )
+# opm-parser to figure out where the source directory is
+if ((NOT OPM_PARSER_INCLUDE_DIR) AND
+        (OPM_PARSER_ROOT AND (EXISTS "${OPM_PARSER_ROOT}/CMakeCache.txt")))
+  set (_regex "^OPMParser_SOURCE_DIR:STATIC=\(.*\)$")
+  file (STRINGS
+        "${OPM_PARSER_ROOT}/CMakeCache.txt"
+        _cache_entry
+        REGEX "${_regex}")
+  string(REGEX REPLACE "${_regex}" "\\1"
+        OPM_PARSER_INCLUDE_DIR
+        "${_cache_entry}")
+  if (OPM_PARSER_INCLUDE_DIR)
+        set (OPM_PARSER_INCLUDE_DIR "${OPM_PARSER_INCLUDE_DIR}"
+          CACHE PATH "Path to OPM parser header files" FORCE)
+  endif ()
 endif ()
 
+# find out the size of a pointer. this is required to only search for
+# libraries in the directories relevant for the architecture
+if (CMAKE_SIZEOF_VOID_P)
+  math (EXPR _BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
+endif ()
+
+# these libraries constitute the parser core
+find_library (OPM_PARSER_LIBRARY
+  NAMES "opmparser"
+  HINTS "${OPM_PARSER_ROOT}"
+  PATHS ${_opm_parser_build}
+  PATH_SUFFIXES "lib" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
+                "opm/parser/eclipse"
+  DOC "Path to OPM parser library archive/shared object files"
+  ${_no_default_path} )
+
+# find the OPM-parser wrapper library around cJSON
+find_library (OPM_JSON_LIBRARY
+  NAMES "opmjson"
+  HINTS "${OPM_PARSER_ROOT}"
+  PATHS ${_opm_parser_build}
+  PATH_SUFFIXES "lib" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}"
+                "opm/json"
+  DOC "Path to OPM JSON library archive/shared object files"
+  ${_no_default_path} )
+
+# get the prerequisite ERT libraries
+if (NOT ERT_FOUND)
+  find_package(ERT ${OPM_PARSER_QUIET})
+endif ()
+
+# get the prerequisite Boost libraries
+find_package(Boost 1.44.0 COMPONENTS filesystem date_time system unit_test_framework regex ${OPM_PARSER_QUIET})
+
+if (ERT_FOUND AND Boost_FOUND AND
+    OPM_PARSER_LIBRARY AND OPM_JSON_LIBRARY AND OPM_PARSER_INCLUDE_DIR)
+  # setup list of all required libraries to link with opm-parser. notice that
+  # we use the plural form to get *all* the libraries needed by cjson
+  set (opm-parser_INCLUDE_DIRS
+    ${OPM_PARSER_INCLUDE_DIR}
+    ${OPM_PARSER_GEN_INCLUDE_DIR}
+    ${Boost_INCLUDE_DIRS}
+    ${ERT_INCLUDE_DIRS})
+
+  set (opm-parser_LIBRARIES
+    ${OPM_PARSER_LIBRARY}
+    ${OPM_JSON_LIBRARY}
+    ${Boost_LIBRARIES}
+    ${ERT_LIBRARIES})
+
+  # see if we can compile a minimum example
+  # CMake logical test doesn't handle lists (sic)
+  include (CMakePushCheckState)
+  include (CheckCSourceCompiles)
+  cmake_push_check_state ()
+  set (CMAKE_REQUIRED_INCLUDES ${opm-parser_INCLUDE_DIRS})
+  set (CMAKE_REQUIRED_LIBRARIES ${opm-parser_LIBRARIES})
+
+  check_cxx_source_compiles (
+      "#include <cstdlib>
+#include <opm/parser/eclipse/Deck/Deck.hpp>
+
+int main (void) {
+   return EXIT_SUCCESS;
+}" HAVE_OPM_PARSER)
+  cmake_pop_check_state ()
+endif()
+
+# if the test program didn't compile, but was required to do so, bail
+# out now and display an error; otherwise limp on
+set (OPM_PARSER_FIND_REQUIRED ${opm-parser_FIND_REQUIRED})
+find_package_handle_standard_args (opm-parser
+  DEFAULT_MSG
+  opm-parser_INCLUDE_DIRS opm-parser_LIBRARIES HAVE_OPM_PARSER
+    )
+
+set (opm-parser_CONFIG_VARS "HAVE_OPM_PARSER;HAVE_REGEX")
+set (opm-parser_FOUND ${OPM-PARSER_FOUND})
+
+mark_as_advanced(opm-parser_LIBRARIES opm-parser_INCLUDE_DIRS OPM-PARSER_FOUND)

cmake/Modules/OpmAliases.cmake

@@ -9,7 +9,6 @@ function (set_aliases)
   # are separated by space
   set (aliases
 	"HAVE_UMFPACK             HAVE_SUITESPARSE_UMFPACK_H"
-	"HAVE_SUITESPARSE_UMFPACK  HAVE_SUITESPARSE_UMFPACK_H"
 	"HAVE_DUNE_BOOST          HAVE_BOOST"
 	)
   foreach (alias IN LISTS aliases)

cmake/Modules/OpmCompile.cmake

@@ -13,53 +13,28 @@ macro (opm_compile opm)
   # all public header files are together with the source. prepend our own
   # source path to the one of the dependencies so that our version of any
   # ambigious paths are used.
-
+  set (${opm}_INCLUDE_DIR "${PROJECT_SOURCE_DIR}")
-  option(SILENCE_CROSSMODULE_WARNINGS "Disable warnings from cross-module includes" OFF)
+  set (${opm}_INCLUDE_DIRS ${${opm}_INCLUDE_DIR} ${${opm}_INCLUDE_DIRS})
-  if (SILENCE_CROSSMODULE_WARNINGS)
-     include_directories("${PROJECT_SOURCE_DIR}")
-     include_directories (SYSTEM ${${opm}_INCLUDE_DIRS})
-     set (${opm}_INCLUDE_DIR "${PROJECT_SOURCE_DIR}")
-     set (${opm}_INCLUDE_DIRS ${${opm}_INCLUDE_DIR} ${${opm}_INCLUDE_DIRS})
-  else()
-     set (${opm}_INCLUDE_DIR "${PROJECT_SOURCE_DIR}")
-     set (${opm}_INCLUDE_DIRS ${${opm}_INCLUDE_DIR} ${${opm}_INCLUDE_DIRS})
-     include_directories (${${opm}_INCLUDE_DIRS})
-  endif()
-
 
   # create this library, if there are any compilation units
+  include_directories (${${opm}_INCLUDE_DIRS})
   link_directories (${${opm}_LIBRARY_DIRS})
   add_definitions (${${opm}_DEFINITIONS})
   set (${opm}_VERSION "${${opm}_VERSION_MAJOR}.${${opm}_VERSION_MINOR}")
   if (${opm}_SOURCES)
-        add_library (${${opm}_TARGET} ${${opm}_LIBRARY_TYPE} ${${opm}_SOURCES})
+	add_library (${${opm}_TARGET} ${${opm}_LIBRARY_TYPE} ${${opm}_SOURCES})
-        set_target_properties (${${opm}_TARGET} PROPERTIES
+	set_target_properties (${${opm}_TARGET} PROPERTIES
-          SOVERSION ${${opm}_VERSION_MAJOR}
+	  SOVERSION ${${opm}_VERSION_MAJOR}
-          VERSION ${${opm}_VERSION}
+	  VERSION ${${opm}_VERSION}
-          LINK_FLAGS "${${opm}_LINKER_FLAGS_STR}"
+	  LINK_FLAGS "${${opm}_LINKER_FLAGS_STR}"
           POSITION_INDEPENDENT_CODE TRUE 
           )
-        if (${${opm}_LIBRARY_TYPE} STREQUAL "SHARED")
+	target_link_libraries (${${opm}_TARGET} ${${opm}_LIBRARIES})
-          # libs that will be linked with the main lib
-          string(REGEX REPLACE "([;^])[^;]+\\.a[;$]" "\\1" _public_libs
-            "${${opm}_LIBRARIES}")
-          # libs that will not actually linked to the library but
-          # transitively linked to binaries that link to the main library
-          string(REGEX REPLACE "([^;]+\\.[^a][a-zA-Z0-9]*|-[a-z]*)[;$]" "" _interface_libs
-            "${${opm}_LIBRARIES}")
-        else()
-          # Use all libs for real and transitive linking
-          set(_public_libs ${${opm}_LIBRARIES})
-          unset(_interface)
-        endif()
-        target_link_libraries (${${opm}_TARGET} PUBLIC ${_public_libs}
-          INTERFACE ${_interface_libs})
 
         if (STRIP_DEBUGGING_SYMBOLS)
 	  # queue this executable to be stripped
 	  strip_debug_symbols (${${opm}_TARGET} ${opm}_DEBUG)
         endif()
-	  add_static_analysis_tests(${opm}_SOURCES ${opm}_INCLUDE_DIRS)
   else (${opm}_SOURCES)
 	# unset this variable to signal that no library is generated
 	set (${opm}_TARGET)

cmake/Modules/OpmFind.cmake

@@ -33,7 +33,6 @@
 #	)
 
 include (Duplicates)
-include (OpmSiblingSearch)
 
 # list of suffixes for all the project variables
 set (_opm_proj_vars
@@ -136,34 +135,15 @@ macro (find_and_append_package_to prefix name)
 	set (${name}_FOUND FALSE)
 	set (${NAME}_FOUND FALSE)
   else ()
-    # using config mode is better than using module (aka. find) mode
+	# using config mode is better than using module (aka. find) mode
-    # because then the package has already done all its probes and
+	# because then the package has already done all its probes and
-    # stored them in the config file for us
+	# stored them in the config file for us
-    # For dune and opm modules and exempted packages we force module mode.
+	if (NOT DEFINED ${name}_FOUND AND NOT DEFINED ${NAME}_FOUND)
-    # For dune and opm it will use config mode underneath.
+	  if (${name}_DIR)
-    # We even need to repeat the search for opm-common once as this is done
+		message (STATUS "Finding package ${name} using config mode")
-    # in the top most CMakeLists.txt without querying defines, setting dependencies
+		find_package (${name} ${ARGN} NO_MODULE PATHS ${${name}_DIR} NO_DEFAULT_PATH)
-    # and the likes which is only done via opm_find_package
+	  else ()
-    if (NOT DEFINED ${name}_FOUND AND NOT DEFINED ${NAME}_FOUND
+		message (STATUS "Finding package ${name} using module mode")
-        OR ("${name}" STREQUAL "opm-common" AND NOT _opm_common_deps_processed))
-      string(REGEX MATCH "(dune|opm)-.*" _is_opm ${name})
-      if (${name}_DIR AND NOT (_${name}_exempted OR _is_opm))
-        message (STATUS "Finding package ${name} using config mode ${_${name}_exempted}")
-        find_package (${name} ${ARGN} NO_MODULE PATHS ${${name}_DIR} NO_DEFAULT_PATH)
-      else ()
-        # print message if this neither an opm module nor ecl
-        if (NOT (${name}_exempted EQUAL -1 OR _is_opm_) )
-          message (STATUS "Finding package ${name} using module mode")
-        endif()
-		if(${name} STREQUAL "ecl")
-			# Give us a chance to find ecl installed to CMAKE_INSTALL_PREFIX.
-			# We need to deactivate the package registry for this.
-			create_module_dir_var(ecl)
-			set(ARGN_NO_REQUIRED ${ARGN})
-			list(REMOVE_ITEM ARGN_NO_REQUIRED "REQUIRED")
- 			find_package (${name} ${ARGN_NO_REQUIRED} NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_PACKAGE_REGISTRY)
-			# If everything else failed fall back to the registry
-		endif()	
 		find_package (${name} ${ARGN})
 	  endif ()
 	endif ()
@@ -173,10 +153,6 @@ macro (find_and_append_package_to prefix name)
 	if (NOT DEFINED ${NAME}_FOUND)
 	  set (${NAME}_FOUND "${${name}_FOUND}")
 	endif ()
-
-       if(name STREQUAL "opm-common")
-         set(_opm_common_deps_processed ON)
-       endif()
   endif ()
 
   # the variable "NAME" may be replaced during find_package (as this is

cmake/Modules/OpmLibMain.cmake

@@ -102,16 +102,6 @@ find_openmp (${project})
 include (UseThreads)
 find_threads (${project})
 
-# SuperLU is optional
-option (USE_SUPERLU "Use SuperLU direct solvers" OFF)
-
-# PETSc is optional
-option (USE_PETSC "Use PETSc iterative solvers" OFF)
-
-# static code analysis
-include(UseStaticAnalysis)
-setup_static_analysis_tools()
-
 # callback hook to setup additional dependencies
 if (COMMAND prereqs_hook)
 	prereqs_hook ()
@@ -295,6 +285,10 @@ opm_doc (${project} ${doxy_dir})
 
 # provide compatibility with using this build in dunecontrol
 include (DuneCompat)
+include (LibtoolArchives)
+if (${project}_TARGET)
+	configure_la (${project} ${${project}_TARGET} ${project}_LIBTOOL_ARCHIVE)
+endif ()
 
 ### clean in-source builds ###
 include (OpmDistClean)

cmake/Modules/OpmPackage.cmake

@@ -37,7 +37,9 @@
 # <http://www.vtk.org/Wiki/CMake:How_To_Find_Libraries>
 
 include (OpmFind)
-include (OpmSiblingSearch)
+
+option (SIBLING_SEARCH "Search sibling directories before system paths" ON)
+mark_as_advanced (SIBLING_SEARCH)
 
 # append all items from src into dst; both must be *names* of lists
 macro (append_found src dst)
@@ -55,15 +57,8 @@ macro (find_opm_package module deps header lib defs prog conf)
   string (REPLACE "-" "_" MODULE "${MODULE_UPPER}")
 
   # if someone else has included this test, don't do it again
-  # one exception is opm-common which is already found in the
-  # top most CMakeLists.txt but we still need to search for its
-  # dependencies
   if (${MODULE}_FOUND OR ${module}_FOUND)
-    if (${module} STREQUAL "opm-common" AND NOT _opm_common_deps_processed)
+	return ()
-      set(_opm_common_deps_processed ON)
-    else()
-      return ()
-    endif()
   endif ()
 
   # variables to pass on to other packages
@@ -78,13 +73,198 @@ macro (find_opm_package module deps header lib defs prog conf)
 	set (_${module}_required "")
   endif (${module}_FIND_REQUIRED)
 
-  create_module_dir_var(${module})
+  # see if there is a pkg-config entry for this package, and use those
+  # settings as a starting point
+  find_package (PkgConfig)
+  pkg_check_modules (PkgConf_${module} QUIET ${module})
 
-  # This will also set all the needed variables with the exception of
+  # these variables have non-standard names in FindPkgConfig (sic)
-  # ${module}_CONFIG_VARS for dune modules.
+  set (${module}_DEFINITIONS ${PkgConf_${module}_CFLAGS_OTHER})
-  find_package(${module} ${_${module}_quiet} ${_${module}_required} CONFIG)
+  set (${module}_LINKER_FLAG ${PkgConf_${module}_LDFLAGS_OTHER})
 
+  # try to figure out whether we are in a subdir build tree, and attempt
+  # to put the same name as the appropriate build tree for the module
+  get_filename_component (_build_dir "${CMAKE_CURRENT_BINARY_DIR}" NAME)
 
+  # don't bother if we are in a project specific directory already
+  # (assuming no-one wants to name the build dir after another module!)
+  if ("${_build_dir}" STREQUAL "${PROJECT_NAME}")
+	set (_build_dir "")
+  endif ("${_build_dir}" STREQUAL "${PROJECT_NAME}")
+
+  # if the user hasn't specified any location, and it isn't found
+  # in standard system locations either, then start to wander
+  # about and look for it in proximity to ourself. Qt Creator likes
+  # to put the build-directories as siblings to the source trees,
+  # but with a -build suffix, DUNE likes to have the the build tree
+  # in a "build-cmake" sub-directory of each module
+  set(workaround_cmake_bug 0)
+  if(${module}_DIR})
+    set(workaround_cmake_bug 1)
+  endif()
+  if(${module}_ROOT})
+    set(workaround_cmake_bug 1)
+  endif()
+  if(${MODULE}_ROOT})
+    set(workaround_cmake_bug 1)
+  endif()
+  if (NOT workaround_cmake_bug)
+	string (TOLOWER "${module}" _module_lower)
+	set (_guess
+	  "../${module}"
+	  "../${_module_lower}"
+	  )
+	set (_guess_bin_only
+	  "../${module}-build"
+	  "../${_module_lower}-build"
+	  )
+
+	# look in similar dirs for the other module
+	if (_build_dir)
+	  list (APPEND _guess_bin_only
+		"../../${module}/${_build_dir}"
+		"../../${_module_lower}/${_build_dir}"
+		)
+	endif (_build_dir)
+
+	# generate items that are in the build, not source dir
+	set (_guess_bin)
+	foreach (_item IN ITEMS ${_guess} ${_guess_bin_only})
+	  list (APPEND _guess_bin "${PROJECT_BINARY_DIR}/${_item}")
+	endforeach (_item)
+	set (_no_system "")
+  else ()
+	# start looking at the paths in this order
+	set (_guess_bin
+	  ${${module}_DIR}
+	  ${${module}_ROOT}
+	  ${${MODULE}_ROOT}
+	  )
+	# if every package is installed directly in the "suite" directory
+	# (e.g. /usr) then allow us to back-track one directory from the
+	# module sub-dir that was added by OpmFind (this happens incidently
+	# already for the source do to the out-of-source support)
+	if ("${${MODULE}_ROOT}" MATCHES "/${module}$")
+	  get_filename_component (_suite_parent ${${MODULE}_ROOT} PATH)
+	  list (APPEND _guess_bin
+		${_suite_parent}
+		${_suite_parent}/${module}
+		${_suite_parent}/${module}/${_build_dir}
+		)
+	endif ("${${MODULE}_ROOT}" MATCHES "/${module}$")
+	# when we look for the source, it may be that we have been specified
+	# a build directory which is a sub-dir of the source, so we look in
+	# the parent also
+	set (_guess
+	  ${${module}_DIR}
+	  ${${module}_ROOT}
+	  ${${MODULE}_ROOT}
+	  )
+	# only add parent directories for those variants that are actually set
+	# (otherwise, we'll inadvertedly add the root directory (=all))
+	if (${module}_DIR)
+	  list (APPEND _guess ${${module}_DIR}/..)
+	endif (${module}_DIR)
+	if (${module}_ROOT)
+	  list (APPEND _guess ${${module}_ROOT}/..)
+	endif (${module}_ROOT)
+	if (${MODULE}_ROOT)
+	  list (APPEND _guess ${${MODULE}_ROOT}/..)
+	endif (${MODULE}_ROOT)
+	# don't search the system paths! that would be dangerous; if there
+	# is a problem in our own specified directory, we don't necessarily
+	# want an old version that is left in one of the system paths!
+	set (_no_system "NO_DEFAULT_PATH")
+  endif ()
+
+  # by specifying _guess in the HINTS section, it gets searched before
+  # the system locations as well. the CMake documentation has a cloudy
+  # recommendation, but it ends up like this: if NO_DEFAULT_PATH is
+  # specified, then PATHS is used. Otherwise, it looks in HINTS, then in
+  # system paths, and the finally in PATHS (!)
+  if (SIBLING_SEARCH)
+	set (_guess_hints ${_guess})
+	set (_guess_hints_bin ${_guess_bin})
+  else (SIBLING_SEARCH)
+	set (_guess_hints)
+	set (_guess_hints_bin)
+  endif (SIBLING_SEARCH)
+
+  # if an include directory is specified directly (e.g. OPM_CORE_INCLUDE_DIR=
+  # /usr/include/opm-2013.03) then this overrides everything else. Notice that
+  # this variable uses the fully capitalized version of the name.
+  if (${MODULE}_INCLUDE_DIR)
+	set (_guess "${${MODULE}_INCLUDE_DIR}")
+	set (_no_system_incl "NO_DEFAULT_PATH")
+  else ()
+	set (_no_system_incl "${_no_system}")
+  endif ()
+
+  # search for this include and library file to get the installation
+  # directory of the package; hints are searched before the system locations,
+  # paths are searched afterwards
+  find_path (${module}_INCLUDE_DIR
+	NAMES "${header}"
+	PATHS ${_guess}
+	HINTS ${PkgConf_${module}_INCLUDE_DIRS} ${_guess_hints}
+	PATH_SUFFIXES "include"
+	${_no_system_incl}
+	)
+
+  # some modules are all in headers
+  if (NOT "${lib}" STREQUAL "")
+	if (CMAKE_SIZEOF_VOID_P)
+	  math (EXPR _BITS "8 * ${CMAKE_SIZEOF_VOID_P}")
+	endif (CMAKE_SIZEOF_VOID_P)
+
+	# again, we may directly override the location of the library alone by
+	# specifying e.g. OPM_CORE_LIB_DIR. notice that this is a *directory*
+	# and not the name of the library
+	if (${MODULE}_LIB_DIR)
+	  set (_guess_bin "${${MODULE}_LIB_DIR}")
+	  set (_no_system_lib "NO_DEFAULT_PATH")
+	else ()
+	  set (_no_system_lib "${_no_system}")
+	endif ()
+
+	# if there is more than one library, then look for all of them, putting
+	# them in variables with the name of the library appended. however, the
+	# first entry is assumed to be the "primary" library and will be named
+	# like the module. thus, with a lib entry of "foo;bar", the first library
+	# is called ${module}_LIBRARY and the second ${module}_LIBRARY_bar
+	foreach (_lib IN ITEMS ${lib})
+	  # don't include any suffix if it is the first one
+	  if ("${lib}" MATCHES "^${_lib}")
+		set (_which)
+	  else ()
+		set (_which "_${_lib}")
+	  endif ()
+	  find_library (${module}_LIBRARY${_which}
+		NAMES "${_lib}"
+		PATHS ${_guess_bin}
+		HINTS ${PkgConf_${module}_LIBRARY_DIRS} ${_guess_hints_bin}
+		PATH_SUFFIXES "lib" "lib/Debug" "lib/Release" "lib/.libs" ".libs" "lib${_BITS}" "lib/${CMAKE_LIBRARY_ARCHITECTURE}" "build-cmake/lib"
+		${_no_system_lib}		
+		)
+	  # debug info if we didn't find the desired library
+	  if (NOT ${module}_LIBRARY${_which})
+		message (STATUS "Failed to find library \"${_lib}\" for module ${module}")
+	  endif ()
+	endforeach (_lib)
+  else (NOT "${lib}" STREQUAL "")
+	set (${module}_LIBRARY "")
+  endif (NOT "${lib}" STREQUAL "")
+
+  # add dependencies so that our result variables are complete
+  # list of necessities to build with the software
+  set (${module}_INCLUDE_DIRS "${${module}_INCLUDE_DIR}")
+  foreach (_lib IN ITEMS ${lib})
+	if ("${lib}" MATCHES "^${_lib}")
+	  set (${module}_LIBRARIES "${${module}_LIBRARY}")
+	else ()
+	  list (APPEND ${module}_LIBRARIES "${${module}_LIBRARY_${_lib}}")
+	endif ()
+  endforeach (_lib)
   # period because it should be something that evaluates to true
   # in find_package_handle_standard_args
   set (${module}_ALL_PREREQS ".")
@@ -129,10 +309,10 @@ macro (find_opm_package module deps header lib defs prog conf)
   # these defines are used in dune/${module} headers, and should be put
   # in config.h when we include those
   foreach (_var IN ITEMS ${conf})
-    # massage the name to remove source code formatting
+	# massage the name to remove source code formatting
-    string (REGEX REPLACE "^[\n\t\ ]+" "" _var "${_var}")
+	string (REGEX REPLACE "^[\n\t\ ]+" "" _var "${_var}")
-    string (REGEX REPLACE "[\n\t\ ]+$" "" _var "${_var}")
+	string (REGEX REPLACE "[\n\t\ ]+$" "" _var "${_var}")
-    list (APPEND ${module}_CONFIG_VARS ${_var})
+	list (APPEND ${module}_CONFIG_VARS ${_var})
   endforeach (_var)
 
   # these are the defines that should be set when compiling
@@ -155,19 +335,51 @@ macro (find_opm_package module deps header lib defs prog conf)
 
   # write status message in the same manner as everyone else
   include (FindPackageHandleStandardArgs)
+  if ("${lib}" STREQUAL "")
+	set (_lib_var "")
+	set (_and_lib_var)
+  else ("${lib}" STREQUAL "")
+	foreach (_lib IN ITEMS ${lib})
+	  if ("${lib}" MATCHES "^${_lib}")
+		set (_lib_var "${module}_LIBRARY")
+		set (_and_lib_var AND ${_lib_var})
+	  else ()
+		list (APPEND _lib_var "${module}_LIBRARY_${_lib}")
+		set (_and_lib_var ${_and_lib_var} AND "${module}_LIBRARY_${_lib}")
+	  endif ()
+	endforeach (_lib)
+  endif ("${lib}" STREQUAL "")
+  # if the search is going to fail, then write these variables to
+  # the console as well as a diagnostics
+  if ((NOT (${module}_INCLUDE_DIR ${_and_lib_var} AND HAVE_${MODULE}))
+	  AND (_${module}_required OR NOT _${module}_quiet))
+	if (DEFINED ${module}_DIR)
+	  message (STATUS "${module}_DIR = ${${module}_DIR}")
+	elseif (DEFINED ${module}_ROOT)
+	  message (STATUS "${module}_ROOT = ${${module}_ROOT}")
+	elseif (DEFINED ${MODULE}_ROOT)
+	  message (STATUS "${MODULE}_ROOT = ${${MODULE}_ROOT}")
+	endif (DEFINED ${module}_DIR)
+  endif ((NOT (${module}_INCLUDE_DIR ${_and_lib_var} AND HAVE_${MODULE}))
+	AND (_${module}_required OR NOT _${module}_quiet))
+  if ("${${module}_ALL_PREREQS}" MATCHES "-NOTFOUND")
+	message (STATUS "${module} prereqs: ${${module}_ALL_PREREQS}")
+  endif ()
   find_package_handle_standard_args (
-        ${module}
+	${module}
-        DEFAULT_MSG
+	DEFAULT_MSG
-        ${module}_INCLUDE_DIRS ${module}_LIBRARIES ${module}_FOUND ${module}_ALL_PREREQS
+	${module}_INCLUDE_DIR ${_lib_var} HAVE_${MODULE} ${module}_ALL_PREREQS
-        )
+	)
+
+  # allow the user to override these from user interface
+  mark_as_advanced (${module}_INCLUDE_DIR)
+  mark_as_advanced (${module}_LIBRARY)
 
   # some genius that coded the FindPackageHandleStandardArgs figured out
   # that the module name should be in uppercase (?!)
   set (${module}_FOUND "${${MODULE_UPPER}_FOUND}")
   set (${MODULE}_FOUND "${${MODULE_UPPER}_FOUND}")
 
-  # This variable is used by UseDuneVer
-  list(GET ${module}_INCLUDE_DIRS 0 ${module}_INCLUDE_DIR)
   # print everything out if we're asked to
   if (${module}_DEBUG)
 	debug_find_vars (${module})

cmake/Modules/OpmSatellites.cmake

@@ -72,7 +72,6 @@ macro (opm_compile_satellites opm satellite excl_all test_regexp)
 	  set (_test_lib "${Boost_UNIT_TEST_FRAMEWORK_LIBRARY}")
 	else (NOT "${test_regexp}" STREQUAL "")
 	  set (_test_lib "")
-	  add_static_analysis_tests(_sat_FILE ${opm}_INCLUDE_DIRS)
 	endif (NOT "${test_regexp}" STREQUAL "")
 	target_link_libraries (${_sat_NAME} ${${opm}_TARGET} ${${opm}_LIBRARIES} ${_test_lib})
         if (STRIP_DEBUGGING_SYMBOLS)
@@ -303,6 +302,11 @@ macro(opm_add_test TestName)
         if(CURTEST_DEPENDS)
           add_dependencies("${CURTEST_EXE_NAME}" ${CURTEST_DEPENDS})
         endif()
+
+        if(NOT TARGET test-suite)
+          add_custom_target(test-suite)
+        endif()
+        add_dependencies(test-suite "${CURTEST_EXE_NAME}")
       endif()
 
       # figure out how the test should be run. if a test driver script
@@ -332,13 +336,6 @@ macro(opm_add_test TestName)
       endif()
     endif()
 
-    if (NOT CURTEST_NO_COMPILE)
-      if(NOT TARGET test-suite)
-        add_custom_target(test-suite)
-      endif()
-      add_dependencies(test-suite "${CURTEST_EXE_NAME}")
-    endif()
-
   else() # test is skipped
 
     # the following causes the test to appear as 'skipped' in the

cmake/Modules/OpmSiblingSearch.cmake

@@ -1,36 +0,0 @@
-option (SIBLING_SEARCH "Search sibling directories before system paths" ON)
-mark_as_advanced (SIBLING_SEARCH)
-
-macro(create_module_dir_var module)
-  if(SIBLING_SEARCH AND NOT ${module}_DIR)
-    # guess the sibling dir
-    get_filename_component(_leaf_dir_name ${PROJECT_BINARY_DIR} NAME)
-    get_filename_component(_parent_full_dir ${PROJECT_BINARY_DIR} DIRECTORY)
-    get_filename_component(_parent_dir_name ${_parent_full_dir} NAME)
-    #Try if <module-name>/<build-dir> is used
-    get_filename_component(_modules_dir ${_parent_full_dir} DIRECTORY)
-    if (module STREQUAL "ecl")
-      #use clone directory libecl
-      set(_clone_dir "libecl")
-    else()
-      set(_clone_dir "${module}")
-    endif()
-    if(IS_DIRECTORY ${_modules_dir}/${_clone_dir}/${_leaf_dir_name})
-      set(${module}_DIR ${_modules_dir}/${_clone_dir}/${_leaf_dir_name})
-    else()
-      string(REPLACE ${PROJECT_NAME} ${_clone_dir} _module_leaf ${_leaf_dir_name})
-      if(NOT _leaf_dir_name STREQUAL _module_leaf
-          AND IS_DIRECTORY ${_parent_full_dir}/${_module_leaf})
-        # We are using build directories named <prefix><module-name><postfix>
-        set(${module}_DIR ${_parent_full_dir}/${_module_leaf})
-      elseif(IS_DIRECTORY ${_parent_full_dir}/${_clone_dir})
-        # All modules are in a common build dir
-        set(${module}_DIR "${_parent_full_dir}/${_clone_dir}}")
-      endif()
-    endif()
-  endif()
-  if(${module}_DIR AND NOT IS_DIRECTORY ${${module}_DIR})
-    message(WARNING "Value ${${module}_DIR} passed to variable"
-      " ${module}_DIR is not a directory")
-  endif()
-endmacro()

cmake/Modules/UseDynamicBoost.cmake

@@ -1,4 +1,6 @@
-find_package (Boost 1.44.0 COMPONENTS unit_test_framework QUIET)
+if (NOT Boost_UNIT_TEST_FRAMEWORK_FOUND)
+  find_package (Boost 1.44.0 COMPONENTS unit_test_framework QUIET)
+endif ()
 
 if (Boost_UNIT_TEST_FRAMEWORK_FOUND)
   # setup to do a test compile

cmake/Modules/UseOptimization.cmake

@@ -38,7 +38,7 @@ if (CXX_COMPAT_GCC)
 
   # default optimization flags, if not set by user
   set_default_option (CXX _opt_dbg "-O0" "(^|\ )-O")
-  set_default_option (CXX _opt_rel "-O3" "(^|\ )-O")
+  set_default_option (CXX _opt_rel "-O2" "(^|\ )-O")
 
   # use these options for debug builds - no optimizations
   add_options (ALL_LANGUAGES "${_prof_DEBUG}" ${_opt_dbg} "-DDEBUG")

cmake/Modules/UseStaticAnalysis.cmake

@@ -1,50 +0,0 @@
-# Add static analysis tests for a given source file
-
-macro(setup_static_analysis_tools)
-  find_package(CppCheck)
-  if(CMAKE_EXPORT_COMPILE_COMMANDS)
-    find_package(ClangCheck)
-  else()
-    message(STATUS "Disabling clang-check as CMAKE_EXPORT_COMPILE_COMMANDS is not enabled")
-  endif()
-  if(OPM_COMMON_ROOT)
-    set(DIR ${OPM_COMMON_ROOT})
-  elseif(OPM_MACROS_ROOT)
-    set(DIR ${OPM_MACROS_ROOT})
-  else()
-    set(DIR ${CMAKE_CURRENT_SOURCE_DIR})
-  endif()
-  if(CPPCHECK_FOUND)
-    file(COPY        ${DIR}/cmake/Scripts/cppcheck-test.sh
-         DESTINATION bin
-         FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
-    endif()
-  if(CLANGCHECK_FOUND AND CMAKE_EXPORT_COMPILE_COMMANDS)
-    configure_file(${DIR}/cmake/Scripts/clang-check-test.sh.in
-                   ${CMAKE_BINARY_DIR}/CMakeFiles/clang-check-test.sh)
-    file(COPY ${CMAKE_BINARY_DIR}/CMakeFiles/clang-check-test.sh
-         DESTINATION bin
-         FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
-   endif()
-endmacro()
-
-function(add_static_analysis_tests sources includes)
-  if(CPPCHECK_FOUND OR (CLANGCHECK_FOUND AND CMAKE_EXPORT_COMPILE_COMMANDS))
-    foreach(dep ${${includes}})
-      list(APPEND IPATHS -I ${dep})
-    endforeach()
-    foreach(src ${${sources}})
-      file(RELATIVE_PATH name ${PROJECT_SOURCE_DIR} ${src})
-      if(CPPCHECK_FOUND)
-        add_test(NAME cppcheck+${name}
-                 COMMAND bin/cppcheck-test.sh ${CPPCHECK_PROGRAM} ${src} ${IPATHS}
-                 CONFIGURATIONS analyze cppcheck)
-      endif()
-      if(CLANGCHECK_FOUND AND CMAKE_EXPORT_COMPILE_COMMANDS)
-        add_test(NAME clang-check+${name}
-                 COMMAND bin/clang-check-test.sh ${CLANGCHECK_PROGRAM} ${src}
-                 CONFIGURATIONS analyze clang-check)
-      endif()
-    endforeach()
-  endif()
-endfunction()

cmake/Modules/ewoms-prereqs.cmake

@@ -35,7 +35,8 @@ set (ewoms_DEPS
 	"dune-fem"
 	"opm-parser"
 	"opm-grid"
-	"opm-core"
+	# librt (on some systems necessary for clock_gettime())
+	"librt REQUIRED"
 	# valgrind client requests
 	"Valgrind"
 	# quadruple precision floating point calculations

cmake/Modules/opm-benchmarks-prereqs.cmake

@@ -0,0 +1,19 @@
+# -*- mode: cmake; tab-width: 2; indent-tabs-mode: t; truncate-lines: t; compile-command: "cmake -Wdev" -*-
+# vim: set filetype=cmake autoindent tabstop=2 shiftwidth=2 noexpandtab softtabstop=2 nowrap:
+
+# defines that must be present in config.h for our headers
+set (opm-benchmarks_CONFIG_VAR
+	)
+
+# dependencies
+set (opm-benchmarks_DEPS
+	# compile with C++0x/11 support if available
+	"CXX11Features REQUIRED"
+	# various runtime library enhancements
+	"Boost 1.44.0
+		COMPONENTS date_time filesystem system unit_test_framework REQUIRED"
+	# OPM dependency
+	"opm-common"
+	"opm-core REQUIRED"
+	"opm-upscaling REQUIRED"
+	)

cmake/Modules/opm-common-prereqs.cmake

@@ -3,7 +3,7 @@
 
 # defines that must be present in config.h for our headers
 set (opm-common_CONFIG_VAR
-	"HAS_ATTRIBUTE_UNUSED")
+	)
 
 # dependencies
 set (opm-common_DEPS

cmake/Modules/opm-core-prereqs.cmake

@@ -8,9 +8,6 @@ set (opm-core_CONFIG_VAR
 	HAVE_DUNE_ISTL
 	HAVE_MPI
 	HAVE_PETSC
-        DUNE_ISTL_VERSION_MAJOR
-        DUNE_ISTL_VERSION_MINOR
-        DUNE_ISTL_VERSION_REVISION
 	)
 
 # dependencies
@@ -29,8 +26,10 @@ set (opm-core_DEPS
 	"SuiteSparse COMPONENTS umfpack"
 	# solver
 	"SuperLU"
+	# xml processing (for config parsing)
+	"TinyXML"
 	# Ensembles-based Reservoir Tools (ERT)
-	"ecl REQUIRED"
+	"ERT REQUIRED"
 	# Look for MPI support
 	"MPI"
 	# PETSc numerical backend
@@ -43,8 +42,5 @@ set (opm-core_DEPS
 	"opm-parser REQUIRED"
 	# the code which implements the material laws
 	"opm-material REQUIRED"
-	# the code which implements the output routines
 	"opm-output REQUIRED"
-	# the code which implements grids
-	"opm-grid REQUIRED"
 	)

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

@@ -12,8 +12,8 @@ set (opm-flowdiagnostics-applications_DEPS
 	# compile with C++0x/11 support if available
 	"CXX11Features REQUIRED"
 	"Boost 1.44.0
-		COMPONENTS filesystem regex system unit_test_framework REQUIRED"
+		COMPONENTS filesystem system unit_test_framework REQUIRED"
-	"ecl REQUIRED"
+	"ERT REQUIRED"
 	# prerequisite OPM modules
 	"opm-common REQUIRED;
 	opm-flowdiagnostics REQUIRED;

cmake/Modules/opm-grid-prereqs.cmake

@@ -6,14 +6,9 @@ set (opm-grid_CONFIG_VAR
 	DUNE_GRID_VERSION_MAJOR
 	DUNE_GRID_VERSION_MINOR
 	DUNE_GRID_VERSION_REVISION
-	DUNE_GEOMETRY_VERSION_MAJOR
-	DUNE_GEOMETRY_VERSION_MINOR
-	DUNE_GEOMETRY_VERSION_REVISION
 	DUNE_COMMON_VERSION_MAJOR
 	DUNE_COMMON_VERSION_MINOR
 	DUNE_COMMON_VERSION_REVISION
-	HAVE_DUNE_ISTL
-	HAVE_MPI
 	HAVE_ZOLTAN
 	)
 
@@ -26,11 +21,12 @@ set (opm-grid_DEPS
 	# various runtime library enhancements
 	"Boost 1.44.0
 		COMPONENTS date_time filesystem system unit_test_framework REQUIRED"
-	"MPI"
+	# DUNE dependency
-	"dune-common"
+	"dune-common REQUIRED;
-	"dune-grid REQUIRED"
+	dune-grid REQUIRED;
-	"dune-istl"
+	dune-geometry REQUIRED"
-	"opm-common REQUIRED"
+	# OPM dependency
-	"opm-parser REQUIRED"
+        "opm-common REQUIRED;
+        opm-core REQUIRED"
 	"ZOLTAN"
 	)

cmake/Modules/opm-material-prereqs.cmake

@@ -20,6 +20,4 @@ set (opm-material_DEPS
 	"opm-common REQUIRED"
 	# DUNE dependency
 	"dune-common REQUIRED"
-	# valgrind client requests
-	"Valgrind"
 	)

cmake/Modules/opm-output-prereqs.cmake

@@ -16,7 +16,7 @@ set (opm-output_DEPS
 	"Boost 1.44.0
 		COMPONENTS unit_test_framework REQUIRED"
 	# Ensembles-based Reservoir Tools (ERT)
-	"ecl REQUIRED"
+	"ERT REQUIRED"
 	# Look for MPI support
 	"opm-common REQUIRED"
 	# Parser library for ECL-type simulation models

cmake/Modules/opm-simulators-prereqs.cmake

@@ -5,11 +5,6 @@
 set (opm-simulators_CONFIG_VAR
 	HAVE_OPM_GRID
 	HAVE_PTHREAD
-	HAVE_EWOMS
-        DUNE_ISTL_VERSION_MAJOR
-        DUNE_ISTL_VERSION_MINOR
-        DUNE_ISTL_VERSION_REVISION
-	HAVE_SUITESPARSE_UMFPACK
 	)
 
 # dependencies
@@ -25,15 +20,12 @@ set (opm-simulators_DEPS
 	"dune-common REQUIRED;
 	dune-istl REQUIRED"
 	"ERTPython"
-	# Tim Davis' SuiteSparse archive
+        # OPM dependency
-	"SuiteSparse COMPONENTS umfpack"
-  # OPM dependency
 	"opm-common REQUIRED;
-   opm-parser REQUIRED;
+        opm-parser REQUIRED;
-	 opm-grid REQUIRED;
+	opm-core REQUIRED;
-	 opm-core REQUIRED;
+	opm-output REQUIRED;
-	 opm-output REQUIRED;
+	opm-grid"
-	 ewoms REQUIRED"
 	# Eigen
 	"Eigen3 3.2.0"
 	)

cmake/Modules/opm-upscaling-prereqs.cmake

@@ -26,7 +26,7 @@ set (opm-upscaling_DEPS
 	dune-geometry REQUIRED;
 	dune-grid REQUIRED;
 	opm-common REQUIRED;
-  opm-grid REQUIRED;
 	opm-core REQUIRED;
+        opm-grid REQUIRED;
 	opm-output REQUIRED"
 	)

cmake/Scripts/clang-check-test.sh.in

@@ -1,23 +0,0 @@
-#!/bin/bash
-
-# This script performs a single analysis using clang-check
-# It is used by the 'make test' target in the buildsystems
-# Usually you should use 'ctest -C clang-check' rather than calling this script directly
-#
-# Parameters: $1 = Application binary
-#             $2 = Source file to process
-
-clangcheck_cmd=$1
-source_file=$2
-
-tmpfil=`mktemp`
-$clangcheck_cmd -p @CMAKE_BINARY_DIR@ -analyze $source_file &> $tmpfil
-cat $tmpfil
-if test -s $tmpfil
-then
-  rm $tmpfil
-  exit 1
-fi
-
-rm $tmpfil
-exit 0

cmake/Scripts/cppcheck-test.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# This script performs a single analysis using cppcheck
-# It is used by the 'make test' target in the buildsystems
-# Usually you should use 'ctest -C cppcheck' rather than calling this script directly
-#
-# Parameters: $1 = Application binary
-#             $2 = Source file to process
-#             $3..$N = include path parameters (-I dir1 -I dir2 ...)
-
-cppcheck_cmd=$1
-source_file=$2
-shift 2
-
-tmpfil=`mktemp`
-$cppcheck_cmd $@ --enable=all --suppress=unusedFunction $source_file &> $tmpfil
-nmatch=`cat $tmpfil | grep "\[.*\]" | wc -l`
-nsys=`cat $tmpfil | grep "\[/usr.*\]" | wc -l`
-nnone=`cat $tmpfil | grep "\[\\*]" | wc -l`
-ndef=`cat $tmpfil | grep "\[.*Too many #ifdef" | wc -l`
-let "nval=$nmatch-$nsys-$nnone-$ndef"
-if test $nval -gt 0
-then
-  cat $tmpfil
-  rm $tmpfil
-  exit 1
-fi
-
-rm $tmpfil
-exit 0

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

@@ -19,55 +19,51 @@
 
 # <http://www.vtk.org/Wiki/CMake/Tutorials/How_to_create_a_ProjectConfig.cmake_file>
 
-# Prevent multiple inclusions
+# propagate these properties from one build system to the other
-if(NOT @opm-project_NAME@_FOUND)
+set (@opm-project_NAME@_VERSION "@opm-project_VERSION@")
+set (@opm-project_NAME@_DEFINITIONS "@opm-project_DEFINITIONS@")
+set (@opm-project_NAME@_INCLUDE_DIRS "@opm-project_INCLUDE_DIRS@")
+set (@opm-project_NAME@_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
+set (@opm-project_NAME@_LINKER_FLAGS "@opm-project_LINKER_FLAGS@")
+set (@opm-project_NAME@_CONFIG_VARS "@opm-project_CONFIG_VARS@")
 
-  # propagate these properties from one build system to the other
+# libraries come from the build tree where this file was generated
-  set (@opm-project_NAME@_VERSION "@opm-project_VERSION@")
+set (@opm-project_NAME@_LIBRARY "@opm-project_LIBRARY@")
-  set (@opm-project_NAME@_DEFINITIONS "@opm-project_DEFINITIONS@")
+set (@opm-project_NAME@_LIBRARIES ${@opm-project_NAME@_LIBRARY} "@opm-project_LIBRARIES@")
-  set (@opm-project_NAME@_INCLUDE_DIRS "@opm-project_INCLUDE_DIRS@")
+mark_as_advanced (@opm-project_NAME@_LIBRARY)
-  set (@opm-project_NAME@_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
-  set (@opm-project_NAME@_LINKER_FLAGS "@opm-project_LINKER_FLAGS@")
-  set (@opm-project_NAME@_CONFIG_VARS "@opm-project_CONFIG_VARS@")
 
-  # libraries come from the build tree where this file was generated
+# not all projects have targets; conditionally add this part
-  set (@opm-project_NAME@_LIBRARY "@opm-project_LIBRARY@")
+if (NOT "@opm-project_TARGET@" STREQUAL "")
-  set (@opm-project_NAME@_LIBRARIES ${@opm-project_NAME@_LIBRARY} "@opm-project_LIBRARIES@")
+  # add the library as a target, so that other things in the project including
-  mark_as_advanced (@opm-project_NAME@_LIBRARY)
+  # this file may depend on it and get rebuild if this library changes.
+  add_library (@opm-project_TARGET@ UNKNOWN IMPORTED)
+  set_property (TARGET @opm-project_TARGET@ PROPERTY IMPORTED_LOCATION "${@opm-project_NAME@_LIBRARY}")
+endif (NOT "@opm-project_TARGET@" STREQUAL "")
 
-  # not all projects have targets; conditionally add this part
+# ensure that we build with support for C++11 to preserve ABI
-  if (NOT "@opm-project_TARGET@" STREQUAL "")
+string (REPLACE "@CXX_STD0X_FLAGS@" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    # add the library as a target, so that other things in the project including
+string (REPLACE "@CXX_STDLIB_FLAGS@" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    # this file may depend on it and get rebuild if this library changes.
+string (STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
-    add_library (@opm-project_TARGET@ UNKNOWN IMPORTED)
+set (CMAKE_CXX_FLAGS "@CXX_STD0X_FLAGS@@CXX_SPACE@@CXX_STDLIB_FLAGS@ ${CMAKE_CXX_FLAGS}")
-    set_property (TARGET @opm-project_TARGET@ PROPERTY IMPORTED_LOCATION "${@opm-project_NAME@_LIBRARY}")
-  endif (NOT "@opm-project_TARGET@" STREQUAL "")
 
-  # ensure that we build with support for C++11 to preserve ABI
+# same as above, but for C99
-  string (REPLACE "@CXX_STD0X_FLAGS@" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+string (REPLACE "@C_STD99_FLAGS@" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-  string (REPLACE "@CXX_STDLIB_FLAGS@" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+string (STRIP "${CMAKE_C_FLAGS}" CMAKE_C_FLAGS)
-  string (STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
+set (CMAKE_C_FLAG "@C_STD99_FLAGS@ ${CMAKE_C_FLAGS}")
-  set (CMAKE_CXX_FLAGS "@CXX_STD0X_FLAGS@@CXX_SPACE@@CXX_STDLIB_FLAGS@ ${CMAKE_CXX_FLAGS}")
 
-  # same as above, but for C99
+# build with OpenMP if that was found
-  string (REPLACE "@C_STD99_FLAGS@" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+if (NOT "@OpenMP_C_FLAGS@" STREQUAL "")
+  string (REPLACE "@OpenMP_C_FLAGS@" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
   string (STRIP "${CMAKE_C_FLAGS}" CMAKE_C_FLAGS)
-  set (CMAKE_C_FLAG "@C_STD99_FLAGS@ ${CMAKE_C_FLAGS}")
+  set (CMAKE_C_FLAG "@OpenMP_C_FLAGS@ ${CMAKE_C_FLAGS}")
+endif (NOT "@OpenMP_C_FLAGS@" STREQUAL "")
+if (NOT "@OpenMP_CXX_FLAGS@" STREQUAL "")
+  string (REPLACE "@OpenMP_CXX_FLAGS@" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  string (STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
+  set (CMAKE_C_FLAG "@OpenMP_CXX_FLAGS@ ${CMAKE_CXX_FLAGS}")
+endif (NOT "@OpenMP_CXX_FLAGS@" STREQUAL "")
 
-  # build with OpenMP if that was found
+# this is the contents of config.h as far as our probes can tell:
-  if (NOT "@OpenMP_C_FLAGS@" STREQUAL "")
-    string (REPLACE "@OpenMP_C_FLAGS@" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-    string (STRIP "${CMAKE_C_FLAGS}" CMAKE_C_FLAGS)
-    set (CMAKE_C_FLAG "@OpenMP_C_FLAGS@ ${CMAKE_C_FLAGS}")
-  endif (NOT "@OpenMP_C_FLAGS@" STREQUAL "")
-  if (NOT "@OpenMP_CXX_FLAGS@" STREQUAL "")
-    string (REPLACE "@OpenMP_CXX_FLAGS@" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-    string (STRIP "${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
-    set (CMAKE_C_FLAG "@OpenMP_CXX_FLAGS@ ${CMAKE_CXX_FLAGS}")
-  endif (NOT "@OpenMP_CXX_FLAGS@" STREQUAL "")
 
-  # this is the contents of config.h as far as our probes can tell:
+# extra code
-
+@OPM_PROJECT_EXTRA_CODE@
-  # extra code
-  @OPM_PROJECT_EXTRA_CODE@
-endif()

debian/changelog

@@ -1,4 +1,10 @@
-opm-common (2017.10-rfinal-1~xenial) xenial; urgency=medium
+opm-common (2016.10-rfinal-1~xenial) xenial; urgency=medium
+
+  * New release
+
+ -- Arne Morten Kvarving <arne.morten.kvarving@sintef.no>  Wed, 26 Oct 2016 09:55:11 +0200
+
+opm-common (2015.10-1~trusty) trusty; urgency=medium
 
   * New release
 

debian/rules

@@ -20,7 +20,7 @@ override_dh_auto_build:
 
 # consider using -DUSE_VERSIONED_DIR=ON if backporting
 override_dh_auto_configure:
-	dh_auto_configure --buildsystem=cmake -- -DCMAKE_BUILD_TYPE=RelWithDebInfo -DSTRIP_DEBUGGING_SYMBOLS=ON -DBUILD_SHARED_LIBS=1 -DCMAKE_INSTALL_DOCDIR=share/doc/libopm-common1 -DWHOLE_PROG_OPTIM=ON -DUSE_RUNPATH=OFF -DWITH_NATIVE=OFF
+	dh_auto_configure --buildsystem=cmake -- -DCMAKE_BUILD_TYPE=RelWithDebInfo -DSTRIP_DEBUGGING_SYMBOLS=ON -DBUILD_SHARED_LIBS=1 -DCMAKE_INSTALL_DOCDIR=share/doc/libopm-common1 -DWHOLE_PROG_OPTIM=ON -DUSE_RUNPATH=OFF
 
 override_dh_auto_install:
 	dh_auto_install -- install-html

dune.module

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

jenkins/build-opm-module.sh

@@ -83,19 +83,9 @@ function build_module {
   test $? -eq 0 || exit 1
   if test $2 -eq 1
   then
-    if [ ! -z $BUILDTHREADS ]
+    cmake --build .
-    then
-      cmake --build . -- -j$BUILDTHREADS
-    else
-      cmake --build .
-    fi
     test $? -eq 0 || exit 2
-    if test -z "$CTEST_CONFIGURATION"
+    ctest -T Test --no-compress-output
-    then
-      ctest -T Test --no-compress-output
-    else
-      ctest -C $CTEST_CONFIGURATION --timeout 5000 -T Test --no-compress-output
-    fi
 
     # Convert to junit format
     $WORKSPACE/deps/opm-common/jenkins/convert.py -x $WORKSPACE/deps/opm-common/jenkins/conv.xsl -t . > testoutput.xml
@@ -106,12 +96,7 @@ function build_module {
       sed -e "s/classname=\"TestSuite\"/classname=\"${configuration}\"/g" testoutput.xml > $WORKSPACE/$configuration/testoutput.xml
     fi
   else
-    if [ ! -z $BUILDTHREADS ]
+    cmake --build . --target install
-    then
-      cmake --build . --target install -- -j$BUILDTHREADS
-    else
-      cmake --build . --target install
-    fi
   fi
 }
 
@@ -124,9 +109,9 @@ function clone_module {
   mkdir -p $WORKSPACE/deps/$1
   cd $WORKSPACE/deps/$1
   git init .
-  if [ "$1" == "libecl" ]
+  if [ "$1" == "ert" ]
   then
-    git remote add origin https://github.com/Statoil/$1
+    git remote add origin https://github.com/Ensembles/$1
   else
     git remote add origin https://github.com/OPM/$1
   fi
@@ -188,13 +173,7 @@ function build_downstreams {
     # Installation for downstream
     pushd .
     cd $WORKSPACE/$configuration/build-$downstream
-
+    cmake --build . --target install
-    if [ ! -z $BUILDTHREADS ]
-    then
-      cmake --build . --target install -- -j$BUILDTHREADS
-    else
-      cmake --build . --target install
-    fi
     popd
     egrep_cmd="$egrep_cmd $WORKSPACE/$configuration/build-$downstream/testoutput.xml"
   done

jenkins/build.sh

@@ -8,27 +8,26 @@ ln -sf $WORKSPACE deps/opm-common
 
 # Downstreams and revisions
 declare -a downstreams
-downstreams=(libecl
+downstreams=(ert
              opm-parser
              opm-output
              opm-material
-             opm-grid
              opm-core
-             ewoms
+             opm-grid
              opm-simulators
              opm-upscaling
-             )
+             ewoms)
 
 declare -A downstreamRev
-downstreamRev[libecl]=master
+downstreamRev[ert]=master
 downstreamRev[opm-parser]=master
 downstreamRev[opm-material]=master
 downstreamRev[opm-core]=master
 downstreamRev[opm-grid]=master
 downstreamRev[opm-output]=master
-downstreamRev[ewoms]=master
 downstreamRev[opm-simulators]=master
 downstreamRev[opm-upscaling]=master
+downstreamRev[ewoms]=master
 
 parseRevisions
 printHeader opm-common

jenkins/update-opm-data.sh

@@ -1,93 +0,0 @@
-#!/bin/bash
-
-MAIN_REPO=$1 # The repo the update was triggered from
-
-source $WORKSPACE/deps/opm-common/jenkins/build-opm-module.sh
-
-declare -a upstreams # Everything is considered an upstream to aid code reuse
-upstreams=(libecl
-           opm-common
-           opm-parser
-           opm-output
-           opm-material
-           opm-grid
-           opm-core
-           ewoms
-           opm-simulators
-           opm-upscaling
-          )
-
-declare -A upstreamRev
-upstreamRev[libecl]=master
-upstreamRev[opm-common]=master
-upstreamRev[opm-parser]=master
-upstreamRev[opm-material]=master
-upstreamRev[opm-core]=master
-upstreamRev[opm-grid]=master
-upstreamRev[opm-output]=master
-upstreamRev[ewoms]=master
-upstreamRev[opm-simulators]=master
-upstreamRev[opm-upscaling]=master
-
-# Setup revision tables
-parseRevisions
-upstreamRev[$MAIN_REPO]=$sha1
-
-# Create branch name
-BRANCH_NAME="update"
-for repo in ${upstreams[*]}
-do
-  if [ "${upstreamRev[$repo]}" != "master" ]
-  then
-    rev=${upstreamRev[$repo]}
-    prnumber=${rev//[!0-9]/}
-    BRANCH_NAME="${BRANCH_NAME}_${repo}_$prnumber"
-    test -n "$REASON" && REASON+="        "
-    REASON+="https://github.com/OPM/$repo/pull/$prnumber\n"
-  fi
-done
-
-# Do the commit
-export REASON
-export BRANCH_NAME
-$WORKSPACE/deps/opm-simulators/tests/update_reference_data.sh $OPM_DATA_ROOT
-
-# Finally open the pull request
-cd $OPM_DATA_ROOT
-git remote add jenkins4opm git@github.com:jenkins4opm/opm-data
-
-# Do some cleaning of old remote branches
-# Easier code with git 2.7+
-#BRANCHES=`git branch --sort=committerdate -r | grep jenkins4opm`
-#NBRANCHES=`git branch --sort=committerdate -r | grep jenkins4opm | wc -l`
-git fetch jenkins4opm # Sadly necessary with older git
-BRANCHES=`git for-each-ref --sort=committerdate refs/remotes/jenkins4opm/ --format='%(refname:short)'`
-NBRANCHES=`git for-each-ref --sort=committerdate refs/remotes/jenkins4opm/ --format='%(refname:short)' | wc -l`
-if test $NBRANCHES -gt 30
-then
-  for BRANCH in $BRANCHES
-  do
-    BNAME=`echo $BRANCH | cut -f1 -d '/' --complement`
-    if [ "$BNAME" != "HEAD" ]
-    then
-      git push jenkins4opm :$BNAME
-    fi
-    NBRANCHES=$((NBRANCHES-1))
-    if test $NBRANCHES -lt 30
-    then
-      break
-    fi
-  done
-fi
-
-if [ -n "`echo $BRANCHES | tr ' ' '\n' | grep ^jenkins4opm/$BRANCH_NAME$`" ]
-then
-  GH_TOKEN=`git config --get gitOpenPull.Token`
-  REV=${upstreamRev[$MAIN_REPO]}
-  PRNUMBER=${rev//[!0-9]/}
-  DATA_PR=`curl -X GET https://api.github.com/repos/OPM/opm-data/pulls?head=jenkins4opm:$BRANCH_NAME | grep '"number":' | awk -F ':' '{print $2}' | sed -e 's/,//'`
-  git push -u jenkins4opm $BRANCH_NAME -f
-  curl -d "{ \"body\": \"Existing PR https://github.com/OPM/opm-data/pull/$DATA_PR was updated\" }" -X POST https://api.github.com/repos/OPM/$MAIN_REPO/issues/$PRNUMBER/comments?access_token=$GH_TOKEN
-else
-  git-open-pull -u jenkins4opm --base-account OPM --base-repo opm-data -r /tmp/cmsg $BRANCH_NAME
-fi

opm/common/Exceptions.hpp

@@ -58,13 +58,6 @@ public:
         : NumericalProblem(message)
     {}
 };
-class TooManyIterations : public NumericalProblem
-{
-public:
-    explicit TooManyIterations(const std::string &message)
-        : NumericalProblem(message)
-    {}
-};
 }
 
 #endif // OPM_EXCEPTIONS_HPP

opm/common/OpmLog/CounterLog.hpp

@@ -33,7 +33,7 @@ namespace Opm {
     class CounterLog : public LogBackend
     {
     public:
-        explicit CounterLog(int64_t messageMask);
+        CounterLog(int64_t messageMask);
         CounterLog();
 
         size_t numMessages(int64_t messageType) const;

opm/common/OpmLog/LogUtil.cpp

@@ -58,16 +58,16 @@ namespace Log {
             prefix = "Info";
             break;
         case MessageType::Warning:
-            prefix = "\nWarning";
+            prefix = "Warning";
             break;
         case MessageType::Error:
-            prefix = "\nError";
+            prefix = "Error";
             break;
         case MessageType::Problem:
-            prefix = "\nProblem";
+            prefix = "Problem";
             break;
         case MessageType::Bug:
-            prefix = "\nBug";
+            prefix = "Bug";
             break;
         default:
             throw std::invalid_argument("Unhandled messagetype");
@@ -85,9 +85,8 @@ namespace Log {
             return message; // No color coding, not even the code for default color.
         case MessageType::Warning:
             return AnsiTerminalColors::blue_strong + message + AnsiTerminalColors::none;
+        case MessageType::Error:
         case MessageType::Problem:
-            return AnsiTerminalColors::magenta_strong + message + AnsiTerminalColors::none;  
-        case MessageType::Error:  
         case MessageType::Bug:
             return AnsiTerminalColors::red_strong + message + AnsiTerminalColors::none;
         default:

opm/common/OpmLog/LogUtil.hpp

@@ -49,8 +49,6 @@ namespace Log {
         const std::string yellow_strong = "\033[33;1m";
         const std::string blue = "\033[34m";
         const std::string blue_strong = "\033[34;1m";
-        const std::string magenta = "\033[35m";
-        const std::string magenta_strong = "\033[35;1m";
         const std::string default_color = "\033[39m";
     }
 

opm/common/OpmLog/MessageFormatter.hpp

@@ -64,7 +64,7 @@ namespace Opm
         }
 
 
-        explicit SimpleMessageFormatter(const bool use_color_coding)
+        SimpleMessageFormatter(const bool use_color_coding)
             : use_color_coding_(use_color_coding)
         {
             prefix_flag_ = Log::MessageType::Warning + Log::MessageType::Error 

opm/common/OpmLog/MessageLimiter.hpp

@@ -62,7 +62,7 @@ namespace Opm
         {
         }
 
-        MessageLimiter(const int tag_limit, const std::map<int64_t, int>& category_limits)
+        MessageLimiter(const int tag_limit, const std::map<int64_t, int> category_limits)
             : tag_limit_(tag_limit < 0 ? NoLimit : tag_limit),
               category_limits_(category_limits)
         {

opm/common/OpmLog/OpmLog.cpp

@@ -21,27 +21,9 @@
 #include <opm/common/OpmLog/Logger.hpp>
 #include <opm/common/OpmLog/StreamLog.hpp>
 #include <iostream>
-#include <errno.h>  // For errno
-#include <stdio.h>  // For fileno() and stdout
-#include <unistd.h> // For isatty()
 
 namespace Opm {
 
-    namespace {
-        bool stdoutIsTerminal()
-        {
-            const int errno_save = errno; // For playing nice with C error handling.
-            const int file_descriptor = fileno(stdout);
-            if (file_descriptor == -1) {
-                // stdout is an invalid stream
-                errno = errno_save;
-                return false;
-            } else {
-                return isatty(file_descriptor);
-            }
-        }
-    }
-
 
     std::shared_ptr<Logger> OpmLog::getLogger() {
         if (!m_logger)
@@ -194,14 +176,12 @@ namespace Opm {
 
 
 
-    void OpmLog::setupSimpleDefaultLogging(const bool use_prefix,
+    void OpmLog::setupSimpleDefaultLogging(const bool use_prefix)
-                                           const bool use_color_coding,
-                                           const int message_limit)
     {
          std::shared_ptr<StreamLog> streamLog = std::make_shared<StreamLog>(std::cout, Log::DefaultMessageTypes);
          OpmLog::addBackend( "SimpleDefaultLog", streamLog);
-         streamLog->setMessageLimiter(std::make_shared<MessageLimiter>(message_limit));
+         streamLog->setMessageLimiter(std::make_shared<MessageLimiter>(10));
-         streamLog->setMessageFormatter(std::make_shared<SimpleMessageFormatter>(use_prefix, use_color_coding && stdoutIsTerminal()));
+         streamLog->setMessageFormatter(std::make_shared<SimpleMessageFormatter>(use_prefix, true));
     }
 /******************************************************************/
 

opm/common/OpmLog/OpmLog.hpp

@@ -64,26 +64,17 @@ public:
     static void removeAllBackends();
     static bool enabledMessageType( int64_t messageType );
     static void addMessageType( int64_t messageType , const std::string& prefix);
-
+    static void setupSimpleDefaultLogging(const bool use_prefix);
-    /// Create a basic logging setup that will send all log messages to standard output.
-    ///
-    /// By default category prefixes will be printed (i.e. Error: or
-    /// Warning:), color coding will be used, and a maximum of 10
-    /// messages with the same tag will be printed. These settings can
-    /// be controlled by the function parameters.
-    static void setupSimpleDefaultLogging(const bool use_prefix = true,
-                                          const bool use_color_coding = true,
-                                          const int message_limit = 10);
 
     template <class BackendType>
     static std::shared_ptr<BackendType> getBackend(const std::string& name) {
-        auto logger = getLogger();
+        auto logger = OpmLog::getLogger();
         return logger->getBackend<BackendType>(name);
     }
 
     template <class BackendType>
     static std::shared_ptr<BackendType> popBackend(const std::string& name) {
-        auto logger = getLogger();
+        auto logger = OpmLog::getLogger();
         return logger->popBackend<BackendType>(name);
     }
 

opm/common/OpmLog/TimerLog.cpp

@@ -32,13 +32,11 @@ namespace Opm {
 TimerLog::TimerLog(const std::string& logFile) : StreamLog( logFile , StopTimer | StartTimer )
 {
     m_work.precision(8);
-    m_start = 0;
 }
 
 TimerLog::TimerLog(std::ostream& os) : StreamLog( os , StopTimer | StartTimer )
 {
     m_work.precision(8);
-    m_start = 0;
 }
 
 

opm/common/OpmLog/TimerLog.hpp

@@ -39,8 +39,8 @@ public:
     static const int64_t StartTimer = 4096;
     static const int64_t StopTimer  = 8192;
 
-    explicit TimerLog(const std::string& logFile);
+    TimerLog(const std::string& logFile);
-    explicit TimerLog(std::ostream& os);
+    TimerLog(std::ostream& os);
 
     void clear();
     ~TimerLog() {};

opm/common/ResetLocale.hpp

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

opm/common/Unused.hpp

@@ -1,43 +0,0 @@
-// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
-// vi: set et ts=4 sw=4 sts=4:
-/*
-  This file is part of the Open Porous Media project (OPM).
-
-  OPM is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  OPM is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/*!
- * \file
- * \brief Provides the OPM_UNUSED macro
- *
- * This macro can be used to mark variables as "potentially unused" which suppresses some
- * bogus compiler warnings. If the compiler does not support this, the macro is a no-op.
- */
-#ifndef OPM_UNUSED_HH
-#define OPM_UNUSED_HH
-
-#ifndef HAS_ATTRIBUTE_UNUSED
-#define OPM_UNUSED
-#else
-#define OPM_UNUSED __attribute__((unused))
-#endif
-
-#ifdef NDEBUG
-#define OPM_DEBUG_UNUSED
-#define OPM_OPTIM_UNUSED OPM_UNUSED
-#else
-#define OPM_DEBUG_UNUSED OPM_UNUSED
-#define OPM_OPTIM_UNUSED
-#endif
-
-#endif

opm/common/Valgrind.hpp

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

opm/common/utility/platform_dependent/disable_warnings.h

@@ -73,9 +73,6 @@
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #pragma GCC diagnostic ignored "-Wcast-align"
-#pragma GCC diagnostic ignored "-Wcast-qual"
-#pragma GCC diagnostic ignored "-Wignored-attributes"
-#pragma GCC diagnostic ignored "-Wmisleading-indentation"
 #endif // COMPATIBLE_COMPILER
 
 #endif // SILENCE_EXTERNAL_WARNINGS

redhat/opm-common.spec

@@ -5,16 +5,16 @@
 %define tag final
 
 Name:           opm-common
-Version:        2017.10
+Version:        2016.10
 Release:        0
 Summary:        Open Porous Media - common helpers and buildsystem
 License:        GPL-3.0
 Group:          Development/Libraries/C and C++
 Url:            http://www.opm-project.org/
 Source0:        https://github.com/OPM/%{name}/archive/release/%{version}/%{tag}.tar.gz#/%{name}-%{version}.tar.gz
-BuildRequires:  git doxygen bc devtoolset-6-toolchain 
+BuildRequires:  git doxygen bc
-%{?el6:BuildRequires: cmake3 boost148-devel}
+%{?el6:BuildRequires: devtoolset-3-toolchain cmake28 boost148-devel}
-%{!?el6:BuildRequires: cmake boost-devel}
+%{!?el6:BuildRequires: gcc gcc-c++ cmake boost-devel}
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build
 
 %description
@@ -48,8 +48,8 @@ This package contains the documentation files for opm-common
 
 # consider using -DUSE_VERSIONED_DIR=ON if backporting
 %build
-scl enable devtoolset-6 bash
+%{?el6:scl enable devtoolset-3 bash}
-%{?el6:cmake28} %{?!el6:cmake} -DBUILD_SHARED_LIBS=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo  -DSTRIP_DEBUGGING_SYMBOLS=ON -DCMAKE_INSTALL_PREFIX=%{_prefix} -DCMAKE_INSTALL_DOCDIR=share/doc/%{name}-%{version} -DUSE_RUNPATH=OFF -DWITH_NATIVE=OFF -DCMAKE_CXX_COMPILER=/opt/rh/devtoolset-6/root/usr/bin/g++ -DCMAKE_C_COMPILER=/opt/rh/devtoolset-6/root/usr/bin/gcc -DCMAKE_Fortran_COMPILER=/opt/rh/devtoolset-6/root/usr/bin/gfortran %{?el6:-DBOOST_LIBRARYDIR=%{_libdir}/boost148 -DBOOST_INCLUDEDIR=%{_includedir}/boost148}
+%{?el6:cmake28} %{?!el6:cmake} -DBUILD_SHARED_LIBS=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo  -DSTRIP_DEBUGGING_SYMBOLS=ON -DCMAKE_INSTALL_PREFIX=%{_prefix} -DCMAKE_INSTALL_DOCDIR=share/doc/%{name}-%{version} -DUSE_RUNPATH=OFF %{?el6:-DCMAKE_CXX_COMPILER=/opt/rh/devtoolset-3/root/usr/bin/g++ -DCMAKE_C_COMPILER=/opt/rh/devtoolset-3/root/usr/bin/gcc -DCMAKE_Fortran_COMPILER=/opt/rh/devtoolset-3/root/usr/bin/gfortran -DBOOST_LIBRARYDIR=%{_libdir}/boost148 -DBOOST_INCLUDEDIR=%{_includedir}/boost148}
 make
 
 %install

tests/test_OpmLog.cpp

@@ -48,8 +48,8 @@ BOOST_AUTO_TEST_CASE(DoLogging) {
 BOOST_AUTO_TEST_CASE(Test_Format) {
     BOOST_CHECK_EQUAL( "There is an error here?\nIn file /path/to/file, line 100\n" , Log::fileMessage("/path/to/file" , 100 , "There is an error here?"));
 
-    BOOST_CHECK_EQUAL( "\nError: This is the error" ,     Log::prefixMessage(Log::MessageType::Error , "This is the error"));
+    BOOST_CHECK_EQUAL( "Error: This is the error" ,     Log::prefixMessage(Log::MessageType::Error , "This is the error"));
-    BOOST_CHECK_EQUAL( "\nWarning: This is the warning" , Log::prefixMessage(Log::MessageType::Warning , "This is the warning"));
+    BOOST_CHECK_EQUAL( "Warning: This is the warning" , Log::prefixMessage(Log::MessageType::Warning , "This is the warning"));
     BOOST_CHECK_EQUAL( "Info: This is the info" ,       Log::prefixMessage(Log::MessageType::Info , "This is the info"));
 }
 
@@ -250,10 +250,10 @@ BOOST_AUTO_TEST_CASE(TestHelperFunctions)
 
     // fileMessage
     BOOST_CHECK_EQUAL(fileMessage("foo/bar", 1, "message"), "message\nIn file foo/bar, line 1\n");
-    BOOST_CHECK_EQUAL(fileMessage(MessageType::Error, "foo/bar", 1, "message"), "\nError: message\nIn file foo/bar, line 1\n");
+    BOOST_CHECK_EQUAL(fileMessage(MessageType::Error, "foo/bar", 1, "message"), "Error: message\nIn file foo/bar, line 1\n");
 
     // prefixMessage
-    BOOST_CHECK_EQUAL(prefixMessage(MessageType::Error, "message"), "\nError: message");
+    BOOST_CHECK_EQUAL(prefixMessage(MessageType::Error, "message"), "Error: message");
     BOOST_CHECK_EQUAL(prefixMessage(MessageType::Info, "message"), "Info: message");
     BOOST_CHECK_EQUAL(prefixMessage(MessageType::Note, "message"), "Note: message");
 
@@ -356,7 +356,7 @@ BOOST_AUTO_TEST_CASE(TestOpmLogWithLimits)
         + Log::colorCodeMessage(Log::MessageType::Info, "Info") + "\n"
         + Log::colorCodeMessage(Log::MessageType::Bug, "Bug") + "\n"
         + Log::colorCodeMessage(Log::MessageType::Warning, "Warning") + "\n"
-        + Log::colorCodeMessage(Log::MessageType::Warning, "Message limit reached for message category: \nWarning") + "\n";
+        + Log::colorCodeMessage(Log::MessageType::Warning, "Message limit reached for message category: Warning") + "\n";
 
     BOOST_CHECK_EQUAL(log_stream2.str(), expected2);
 

travis/build-and-test-opm-common.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -e
+
+pushd . > /dev/null
+opm-common/travis/build-opm-common.sh
+cd opm-common/build
+ctest --output-on-failure
+popd > /dev/null

travis/build-and-test.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -e
 
-build_order=(opm-common opm-parser opm-output opm-material opm-grid opm-core ewoms opm-simulators)
+build_order=(opm-common opm-parser opm-material opm-output opm-core opm-grid ewoms opm-simulators opm-upscaling)
 
 # This shell script should be started with the name of a module as
 # only only command line argument. It will start by building all
@@ -30,7 +30,7 @@ function upstream_build {
     echo "Building: ${project}"
     mkdir -p ${project}/build
     pushd ${project}/build > /dev/null
-    cmake ../ -DENABLE_PYTHON=ON -DBUILD_TESTING=OFF -DSILENCE_EXTERNAL_WARNINGS=ON -DUSE_QUADMATH=OFF -DADD_DISABLED_CTESTS=OFF
+    cmake ../ -DENABLE_PYTHON=ON -DBUILD_TESTING=OFF -DSILENCE_EXTERNAL_WARNINGS=True -DUSE_QUADMATH=OFF -DADD_DISABLED_CTESTS=OFF
     make 
     popd > /dev/null
 }
@@ -44,14 +44,9 @@ function downstream_build_and_test {
     # The build commands cmake, make and ctest must be given as
     # separate commands and not chained with &&. If chaining with &&
     # is used the 'set -e' does not exit on first error.
-    if [ "$project" == "ewoms" ]; then
+    cmake ../ -DENABLE_PYTHON=ON -DBUILD_TESTING=ON -DSILENCE_EXTERNAL_WARNINGS=True -DUSE_QUADMATH=OFF -DADD_DISABLED_CTESTS=OFF
-       cmake ../ -DENABLE_PYTHON=ON -DBUILD_TESTING=OFF -DSILENCE_EXTERNAL_WARNINGS=ON -DUSE_QUADMATH=OFF -DADD_DISABLED_CTESTS=OFF
+    make
-       make
+    ctest --output-on-failure
-    else
-       cmake ../ -DENABLE_PYTHON=ON -DBUILD_TESTING=ON -DSILENCE_EXTERNAL_WARNINGS=ON -DUSE_QUADMATH=OFF -DADD_DISABLED_CTESTS=OFF
-       make
-       ctest --output-on-failure
-    fi
     popd > /dev/null
 }
 

travis/build-opm-common-shared.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -e
+
+pushd . > /dev/null
+cd opm-common
+mkdir build
+cd build
+cmake ../ -DBUILD_SHARED_LIBS=ON
+make
+popd > /dev/null

travis/build-opm-common.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -e
+
+pushd . > /dev/null
+cd opm-common
+mkdir build
+cd build
+cmake ../
+make
+popd > /dev/null

travis/build-prereqs.sh

@@ -25,7 +25,7 @@ function build_dune {
    pushd . > /dev/null
    git clone ${url}
    cd ${project}
-   git checkout tags/v2.4.1
+   git checkout tags/v2.3.1
    mkdir build
    cd build
    cmake ../
@@ -62,11 +62,11 @@ function install_python_deps {
 }
 
 
-function build_libecl {
+function build_ert {
     install_python_deps
-    git clone https://github.com/Statoil/libecl.git
+    git clone https://github.com/Ensembles/ert.git
-    mkdir -p libecl/build
+    mkdir -p ert/build
-    pushd libecl/build > /dev/null
+    pushd ert/build > /dev/null
     cmake .. && make
     popd > /dev/null
 }
@@ -75,7 +75,7 @@ function build_libecl {
 #################################################################
 
 build_superlu
-build_libecl
+build_ert
 
 build_dune dune-common
 build_dune dune-istl