AMDiS/cmake3/amdis_extensions.cmake

+if (ENABLE_EXTENSIONS)
+    option(ENABLE_BASE_PROBLEMS "Use base_problems" true)
+    mark_as_advanced(ENABLE_BASE_PROBLEMS)
+
+    find_path(EXTENSIONS_DIR NAMES Helpers.h
+        HINTS ${BASE_DIR}/../extensions
+        DOC "Path to AMDiS extensions.")
+    if (EXTENSIONS_DIR)
+        if (NOT EXISTS ${EXTENSIONS_DIR}/Helpers.h OR NOT EXISTS ${EXTENSIONS_DIR}/ExtendedProblemStat.h)
+            message(FATAL_ERROR "Wrong extensions directory! Directory must contain the files 'Helpers.h' and 'ExtendedProblemStat.h'")
+        endif ()
+
+        add_library(amdis_extensions
+            ${EXTENSIONS_DIR}/Helpers.cc
+            ${EXTENSIONS_DIR}/BackgroundMesh.cc
+            ${EXTENSIONS_DIR}/GeometryTools.cc
+            ${EXTENSIONS_DIR}/POperators.cc
+            ${EXTENSIONS_DIR}/SingularDirichletBC2.cc
+            ${EXTENSIONS_DIR}/time/ExtendedRosenbrockStationary.cc
+            ${EXTENSIONS_DIR}/pugixml/src/pugixml.cpp
+        )
+        add_library(AMDiS::extensions ALIAS amdis_extensions)
+
+        target_compile_definitions(amdis_extensions PRIVATE HAVE_EXTENSIONS=1)
+        target_include_directories(amdis_extensions PRIVATE
+            ${EXTENSIONS_DIR}
+            ${EXTENSIONS_DIR}/time
+            ${EXTENSIONS_DIR}/nanoflann
+            ${EXTENSIONS_DIR}/pugixml/src
+        )
+
+        set(INSTALL_SUBDIRS . time preconditioner nanoflann)
+
+        if (ENABLE_SEQ_PETSC)
+            target_sources(amdis_extensions PRIVATE
+                ${EXTENSIONS_DIR}/preconditioner/PetscPreconPfc.cc
+                ${EXTENSIONS_DIR}/preconditioner/PetscPreconPfcDiag.cc
+                ${EXTENSIONS_DIR}/preconditioner/PetscPreconCahnHilliard.cc)
+        endif (ENABLE_SEQ_PETSC)
+
+        if (ENABLE_PARALLEL_DOMAIN)
+            target_sources(amdis_extensions PRIVATE
+                ${EXTENSIONS_DIR}/preconditioner/PetscSolverPfc.cc
+                ${EXTENSIONS_DIR}/preconditioner/PetscSolverPfc_diag.cc)
+            target_link_libraries(amdis_extensions amdis_parallel)
+        endif (ENABLE_PARALLEL_DOMAIN)
+
+      if (ENABLE_BASE_PROBLEMS)
+            if (ENABLE_REINIT)
+                target_sources(amdis_extensions PRIVATE
+                    ${EXTENSIONS_DIR}/base_problems/CahnHilliard.cc
+                    ${EXTENSIONS_DIR}/base_problems/CahnHilliard_RB.cc
+                    ${EXTENSIONS_DIR}/base_problems/CahnHilliardNavierStokes.cc
+                    ${EXTENSIONS_DIR}/base_problems/CahnHilliardNavierStokes_RB.cc
+                    ${EXTENSIONS_DIR}/base_problems/CahnHilliardNavierStokes_TwoPhase.cc
+                    ${EXTENSIONS_DIR}/base_problems/CahnHilliardNavierStokes_TwoPhase_RB.cc)
+            endif (ENABLE_REINIT)
+            target_sources(amdis_extensions PRIVATE
+                ${EXTENSIONS_DIR}/base_problems/DiffuseDomainFsi.cc
+                ${EXTENSIONS_DIR}/base_problems/LinearElasticity.cc
+                ${EXTENSIONS_DIR}/base_problems/LinearElasticityPhase.cc
+                ${EXTENSIONS_DIR}/base_problems/NavierStokesCahnHilliard.cc
+                ${EXTENSIONS_DIR}/base_problems/NavierStokesPhase_TaylorHood.cc
+                ${EXTENSIONS_DIR}/base_problems/NavierStokes_TaylorHood.cc
+                ${EXTENSIONS_DIR}/base_problems/NavierStokes_TaylorHood_RB.cc
+                ${EXTENSIONS_DIR}/base_problems/NavierStokes_TH_MultiPhase.cc
+                ${EXTENSIONS_DIR}/base_problems/NavierStokes_TH_MultiPhase_RB.cc
+                ${EXTENSIONS_DIR}/base_problems/PhaseFieldCrystal.cc
+                ${EXTENSIONS_DIR}/base_problems/PhaseFieldCrystal_Phase.cc
+                ${EXTENSIONS_DIR}/base_problems/PhaseFieldCrystal_RB.cc
+                ${EXTENSIONS_DIR}/base_problems/PolarizationField.cc
+                ${EXTENSIONS_DIR}/base_problems/QuasiCrystal.cc
+                ${EXTENSIONS_DIR}/base_problems/QuasiCrystal_RB.cc)
+                # 		  ${EXTENSIONS_DIR}/base_problems/NavierStokes_Chorin.cc
+                # 		  ${EXTENSIONS_DIR}/base_problems/NavierStokesPhase_Chorin.cc
+                # 		  ${EXTENSIONS_DIR}/base_problems/VacancyPhaseFieldCrystal.cc
+
+            target_compile_definitions(amdis_extensions PRIVATE HAVE_BASE_PROBLEMS=1)
+            target_include_directories(amdis_extensions PRIVATE ${EXTENSIONS_DIR}/base_problems)
+
+            list(APPEND INSTALL_SUBDIRS base_problems)
+        endif (ENABLE_BASE_PROBLEMS)
+
+        target_link_libraries(amdis_extensions amdis amdis_reinit)
+
+        # specify how to install this target:
+        # -----------------------------------
+
+        foreach (SUBDIR ${INSTALL_SUBDIRS})
+            file(GLOB HEADERS "${EXTENSIONS_DIR}/${SUBDIR}/*.h*")
+            install(FILES ${HEADERS} DESTINATION include/amdis/extensions/${SUBDIR}/)
+        endforeach ()
+
+        file(GLOB HEADERS "${EXTENSIONS_DIR}/pugixml/src/*.hpp")
+        install(FILES ${HEADERS} DESTINATION include/amdis/extensions/pugixml/)
+
+        set_target_properties(amdis_extensions PROPERTIES OUTPUT_NAME amdisextensions${POSTFIX}
+                                                    DEBUG_OUTPUT_NAME amdisextensions${POSTFIX}d)
+        install(TARGETS amdis_extensions DESTINATION lib/amdis/)
+
+    endif (EXTENSIONS_DIR)
+endif (ENABLE_EXTENSIONS)

AMDiS/cmake3/amdis_parallel.cmake

+if (ENABLE_PARALLEL_DOMAIN)
+    add_library(amdis_parallel INTERFACE)
+    target_sources(amdis PRIVATE
+        ${SOURCE_DIR}/parallel/DofComm.cc
+        ${SOURCE_DIR}/parallel/CheckerPartitioner.cc
+        ${SOURCE_DIR}/parallel/ElementObjectDatabase.cc
+        ${SOURCE_DIR}/parallel/InteriorBoundary.cc
+        ${SOURCE_DIR}/parallel/MeshDistributor.cc
+        ${SOURCE_DIR}/parallel/MeshLevelData.cc
+        ${SOURCE_DIR}/parallel/MeshManipulation.cc
+        ${SOURCE_DIR}/parallel/MeshPartitioner.cc
+        ${SOURCE_DIR}/parallel/MpiHelper.cc
+        ${SOURCE_DIR}/parallel/ParallelDebug.cc
+        ${SOURCE_DIR}/parallel/ParallelDofMapping.cc
+        ${SOURCE_DIR}/parallel/ParallelProblemStat.cc
+        ${SOURCE_DIR}/parallel/ParallelSolver.cc
+        ${SOURCE_DIR}/parallel/PeriodicMap.cc
+        ${SOURCE_DIR}/parallel/ParMetisPartitioner.cc
+        ${SOURCE_DIR}/parallel/StdMpi.cc
+    )
+
+    target_compile_definitions(amdis_parallel INTERFACE
+	   HAVE_PARALLEL_DOMAIN_AMDIS=1)
+
+    target_enable_petsc(amdis_parallel INTERFACE)
+
+    # add support for the zoltan library
+    if (ENABLE_ZOLTAN)
+      target_enable_zoltan(amdis_parallel INTERFACE)
+      target_sources(amdis PRIVATE
+          ${SOURCE_DIR}/parallel/ZoltanPartitioner.cc)
+    endif (ENABLE_ZOLTAN)
+
+    if (ENABLE_BDDCML)
+      target_compile_definitions(amdis_parallel INTERFACE HAVE_BDDCML=1)
+      target_sources(amdis PRIVATE
+          ${SOURCE_DIR}/parallel/BddcMlSolver.cc)
+    endif (ENABLE_BDDCML)
+
+    # add some more source-files that need petsc
+    target_sources(amdis PRIVATE
+        ${SOURCE_DIR}/parallel/MatrixNnzStructure.cc
+        ${SOURCE_DIR}/parallel/ParallelCoarseSpaceSolver.cc
+        ${SOURCE_DIR}/parallel/PetscHelper.cc
+        ${SOURCE_DIR}/parallel/PetscSolver.cc
+        ${SOURCE_DIR}/parallel/PetscSolverGlobalMatrix.cc
+        ${SOURCE_DIR}/parallel/PetscSolverGlobalBlockMatrix.cc
+        ${SOURCE_DIR}/solver/PetscTypes.cc
+    )
+
+    if (ENABLE_PARALLEL_SOLVERS)
+        target_sources(amdis PRIVATE
+            ${SOURCE_DIR}/parallel/PetscSolverFeti.cc
+            ${SOURCE_DIR}/parallel/PetscSolverFetiDebug.cc
+            ${SOURCE_DIR}/parallel/PetscSolverFetiMonitor.cc
+            ${SOURCE_DIR}/parallel/PetscSolverFetiOperators.cc
+            ${SOURCE_DIR}/parallel/PetscSolverFetiTimings.cc
+            ${SOURCE_DIR}/parallel/PetscSolverNavierStokes.cc
+            ${SOURCE_DIR}/parallel/PetscSolverNSCH.cc
+            ${SOURCE_DIR}/parallel/PetscSolverCahnHilliard2.cc
+            ${SOURCE_DIR}/parallel/PetscSolverCahnHilliard.cc
+            ${SOURCE_DIR}/parallel/PetscSolverSchur.cc
+        )
+        target_compile_definitions(amdis_parallel INTERFACE
+            HAVE_PARALLEL_SOLVERS=1)
+    endif (ENABLE_PARALLEL_SOLVERS)
+
+    target_link_libraries(amdis amdis_parallel)
+
+    # specify how to install this target:
+    # -----------------------------------
+
+    file(GLOB AMDIS_PARALLEL_HEADERS "${SOURCE_DIR}/parallel/*.h")
+    install(FILES ${AMDIS_PARALLEL_HEADERS} DESTINATION include/amdis/parallel/)
+
+    install(FILES
+        ${BASE_DIR}/cmake3/ResolveCompilerPaths.cmake
+        ${BASE_DIR}/cmake3/FindPackageMultipass.cmake
+        ${BASE_DIR}/cmake3/CorrectWindowsPaths.cmake
+        ${BASE_DIR}/cmake3/FindPETSc.cmake
+        ${BASE_DIR}/cmake3/target_enable_petsc.cmake
+        ${BASE_DIR}/cmake3/target_enable_zoltan.cmake
+        DESTINATION share/amdis/)
+endif (ENABLE_PARALLEL_DOMAIN)

AMDiS/cmake3/amdis_reinit.cmake

+# specify the target and requirements for the reinit library
+
+SET(COMPOSITE_SOURCE_DIR ${SOURCE_DIR}/reinit)
+set(REINIT_SOURCE_DIR ${SOURCE_DIR}/reinit)
+
+file(GLOB REINIT_SRC ${REINIT_SOURCE_DIR}/*.cc)
+add_library(amdis_reinit ${REINIT_SRC})
+add_library(AMDiS::reinit ALIAS amdis_reinit)
+
+target_compile_definitions(amdis_reinit PUBLIC
+    HAVE_REINIT=1)
+target_include_directories(amdis_reinit PUBLIC ${REINIT_SOURCE_DIR})
+target_link_libraries(amdis_reinit amdis)
+
+# specify how to install this target:
+# -----------------------------------
+
+file(GLOB RINIT_HEADERS "${REINIT_SOURCE_DIR}/*.h*")
+install(FILES ${RINIT_HEADERS} DESTINATION include/amdis/reinit)
+
+
+set_target_properties(amdis_reinit PROPERTIES OUTPUT_NAME amdisreinit${POSTFIX}
+                                        DEBUG_OUTPUT_NAME amdisreinit${POSTFIX}d)
+install(TARGETS amdis_reinit DESTINATION lib/amdis/ )

AMDiS/cmake3/amdis_seq_petsc.cmake

+if (ENABLE_SEQ_PETSC)
+  target_enable_mpi(amdis PUBLIC)
+  target_enable_petsc(amdis PUBLIC)
+
+  target_compile_definitions(amdis PUBLIC HAVE_SEQ_PETSC=1)
+
+  target_sources(amdis PRIVATE
+	${SOURCE_DIR}/solver/PetscSolver.cc
+	${SOURCE_DIR}/solver/PetscTypes.cc)
+endif (ENABLE_SEQ_PETSC)

AMDiS/cmake3/muparser.cmake

+# specify the target and requirements for the muparser library
+
+set(MUPARSER_SOURCE_DIR ${BASE_DIR}/lib/muparser_v134/src)
+set(MUPARSER_INCLUDE_DIR ${BASE_DIR}/lib/muparser_v134/include)
+add_library(muparser STATIC
+    ${MUPARSER_SOURCE_DIR}/muParser.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserBase.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserBytecode.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserCallback.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserComplex.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserDLL.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserError.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserInt.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserTest.cpp
+    ${MUPARSER_SOURCE_DIR}/muParserTokenReader.cpp)
+
+target_include_directories(muparser PUBLIC ${MUPARSER_INCLUDE_DIR})
+set_property(TARGET muparser PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+target_enable_cxx11(MUPARSER_ENABLE_CXX11 muparser PRIVATE)
+target_compile_definitions(muparser PRIVATE AMDIS_HAS_CXX11=1)
+
+# specify how to install this target:
+# -----------------------------------
+
+file(GLOB MUPARSER_HEADERS "${MUPARSER_SOURCE_DIR}/include/*.h")
+install(FILES ${MUPARSER_HEADERS}
+	DESTINATION include/amdis/muparser)
+install(TARGETS muparser
+	DESTINATION lib/amdis/ )

AMDiS/cmake3/parse_zoltan_makefile.cmake

+macro(parse_zoltan_makefile _FILE_ _TARGET_ _SCOPE_)
+
+  # parse zoltan extra libs AND ld flags
+  file(STRINGS ${_FILE_} ZOLTAN_EXTRA_LIBS_LINE REGEX "ZOLTAN_EXTRA_LIBS")
+  file(STRINGS ${_FILE_} ZOLTAN_LDFLAGS_LINE REGEX "ZOLTAN_LDFLAGS")
+  get_filename_component(ZOLTAN_MAKEFILE_DIR "${ZOLTAN_MAKEFILE}" PATH CACHE)
+
+  string(STRIP "${ZOLTAN_EXTRA_LIBS_LINE}" ZOLTAN_EXTRA_LIBS_LINE)
+  string(STRIP "${ZOLTAN_LDFLAGS_LINE}" ZOLTAN_LDFLAGS_LINE)
+  if ("${ZOLTAN_EXTRA_LIBS_LINE}" MATCHES "^ZOLTAN_EXTRA_LIBS[ ]*=[ ]*([a-zA-Z0-9_/. -]+)*$")
+    string(REGEX REPLACE " " ";" ZOLTAN_EXTRA_LIBS_LIST "${CMAKE_MATCH_1}")
+    if ("${ZOLTAN_LDFLAGS_LINE}" MATCHES "^ZOLTAN_LDFLAGS[ ]*=[ ]*([a-zA-Z0-9_/. -]+)*$")
+      string(REGEX REPLACE " " ";" ZOLTAN_LDFLAGS_LIST "${CMAKE_MATCH_1}")
+      set(COMBINED_LIST ${ZOLTAN_LDFLAGS_LIST} ${ZOLTAN_EXTRA_LIBS_LIST})
+
+      set(ZOLTAN_LIB_DIRS "")
+      foreach(LIBS ${COMBINED_LIST})
+        string(STRIP "${LIBS}" LIBS)
+        string(SUBSTRING "${LIBS}" 0 2 LIB_PREFIX)
+        string(SUBSTRING "${LIBS}" 2 -1 LIB_NAME)
+        if ("${LIB_PREFIX}" STREQUAL "-L")
+          list(APPEND ZOLTAN_LIB_DIRS ${LIB_NAME})
+        elseif ("${LIB_PREFIX}" STREQUAL "-l")
+          find_library(_ZOLTAN_EXTERN_LIB ${LIB_NAME} HINTS ${ZOLTAN_LIB_DIRS})
+          if (NOT _ZOLTAN_EXTERN_LIB)
+            message(FATAL_ERROR "Could not find library \"${LIB_NAME}\" in directories ${ZOLTAN_LIB_DIRS}!")
+          else ()
+            target_link_libraries(${_TARGET_} ${_SCOPE_} ${_ZOLTAN_EXTERN_LIB})
+          endif ()
+          unset(_ZOLTAN_EXTERN_LIB CACHE)
+        else ()
+          message(WARNING "Unknown link parameter \"${LIBS}\"")
+        endif ()
+      endforeach (LIBS)
+    endif()
+  endif()
+endmacro(parse_zoltan_makefile)
+

AMDiS/cmake3/target_enable_bddcml.cmake

+macro(target_enable_bddcml _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    SET(BDDCML_LINK_LIST "" CACHE STRING "Further libraries to be linked with BDDCML")
+
+    find_file(BDDCML_H bddcml_interface_c.h
+      HINTS ENV CPATH
+      DOC "Header bddcml_interface_c.h for the BDDCML library.")
+
+    if (BDDCML_H)
+      get_filename_component(BDDCML_PATH ${BDDCML_H} PATH)
+      target_include_directories(${_TARGET_} ${_SCOPE_} ${BDDCML_PATH})
+      target_compile_definitions(${_TARGET_} ${_SCOPE_} HAVE_BDDC_ML=1 Add_)
+    else()
+      message(FATAL_ERROR "Could not find BDDCML headers.")
+    endif()
+
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(BDDCML_LIB bddcml
+        HINTS ENV LIBRARY_PATH
+        DOC "BDDCML library")
+
+      if(BDDCML_LIB)
+        target_link_libraries(${_TARGET_} ${_SCOPE_} ${BDDCML_LIB})
+      else()
+        message(FATAL_ERROR "Could not find the BDDCML library")
+      endif()
+    endif (LINK_EXECUTABLE OR APPLE)
+
+    target_compile_definitions(${_TARGET_} ${_SCOPE_} HAVE_BDDCML=1)
+endmacro(target_enable_bddcml)

AMDiS/cmake3/target_enable_boost.cmake

+macro(target_enable_boost _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    if (BOOST_ROOT)
+        file(TO_CMAKE_PATH ${BOOST_ROOT} BOOST_ROOT)
+    endif (BOOST_ROOT)
+    if (BOOST_LIBRARYDIR)
+        file(TO_CMAKE_PATH ${BOOST_LIBRARYDIR} BOOST_LIBRARYDIR)
+    endif (BOOST_LIBRARYDIR)
+
+    set(BOOST_VERSION "1.48")
+    set(BOOST_LIBS_REQUIRED system iostreams filesystem program_options date_time)
+    if (WIN32)
+      list(APPEND BOOST_LIBS_REQUIRED zlib)
+      if (ENABLE_COMPRESSION OR AMDIS_NEED_COMPRESSION)
+        list(APPEND BOOST_LIBS_REQUIRED bzip2)
+      endif (ENABLE_COMPRESSION OR AMDIS_NEED_COMPRESSION)
+    endif (WIN32)
+
+    if (NOT BUILD_SHARED_LIBS)
+        set(Boost_USE_STATIC_LIBS ON)
+    endif (NOT BUILD_SHARED_LIBS)
+
+    find_package(Boost ${BOOST_VERSION} REQUIRED ${BOOST_LIBS_REQUIRED})
+    target_include_directories(${_TARGET_} ${_SCOPE_} ${Boost_INCLUDE_DIR})
+
+    if (LINK_EXECUTABLE OR APPLE)
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${Boost_LIBRARIES})
+    endif (LINK_EXECUTABLE OR APPLE)
+
+    if (MSVC_SHARED_LIBS AND LINK_EXECUTABLE)
+      link_directories(${Boost_LIBRARY_DIRS})
+      target_compile_definitions(${_TARGET_} ${_SCOPE_} ${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
+    endif (MSVC_SHARED_LIBS AND LINK_EXECUTABLE)
+
+endmacro(target_enable_boost)

AMDiS/cmake3/target_enable_cxx11.cmake

+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+macro(target_enable_cxx14 RESULT_VAR _TARGET_ _SCOPE_)
+  check_cxx_compiler_flag("-std=c++14" COMPILER_SUPPORTS_CXX14_FLAG)
+
+  set(CXX14_CODE "
+  auto f() { return 1; }
+  int main(){
+    auto f1 = [](auto const& y) { return y; };
+    auto y0 = f();
+    auto y1 = f1(1);
+  }")
+
+  if (COMPILER_SUPPORTS_CXX14_FLAG)
+    set(CMAKE_REQUIRED_FLAGS "-std=c++14")
+    check_cxx_source_compiles("${CXX14_CODE}" CXX14_COMPILES_WITH_CXX14_FLAG)
+    set(CMAKE_REQUIRED_FLAGS "")
+  endif ()
+
+  if (COMPILER_SUPPORTS_CXX14_FLAG AND CXX14_COMPILES_WITH_CXX14_FLAG)
+    target_compile_options(${_TARGET_} ${_SCOPE_} "-std=c++14")
+    set(${RESULT_VAR} true CACHE BOOL "Enable C++14 compiler features" FORCE)
+  else ()
+    check_cxx_source_compiles("${CXX14_CODE}" CXX14_COMPILES)
+
+    if (CXX14_COMPILES)
+      set(${RESULT_VAR} true CACHE BOOL "Enable C++14 compiler features" FORCE)
+    else ()
+      set(${RESULT_VAR} false CACHE BOOL "Enable C++14 compiler features" FORCE)
+    endif ()
+  endif ()
+endmacro(target_enable_cxx14)
+
+macro(target_enable_cxx11 RESULT_VAR _TARGET_ _SCOPE_)
+  check_cxx_compiler_flag("-std=c++11" COMPILER_SUPPORTS_CXX11_FLAG)
+
+  set(CXX11_CODE "
+  #include <array>
+  #include <tuple>
+  template <class... T> using A = std::tuple<T...>;
+  int main(){
+    decltype(1) vec[]={1,2,3};
+    for(auto&& x:vec);
+  }")
+
+  if (COMPILER_SUPPORTS_CXX11_FLAG)
+    set(CMAKE_REQUIRED_FLAGS "-std=c++11")
+    check_cxx_source_compiles("${CXX11_CODE}" CXX11_COMPILES_WITH_CXX11_FLAG)
+    set(CMAKE_REQUIRED_FLAGS "")
+  endif ()
+
+  if (COMPILER_SUPPORTS_CXX11_FLAG AND CXX11_COMPILES_WITH_CXX11_FLAG)
+    target_compile_options(${_TARGET_} ${_SCOPE_} "-std=c++11")
+    set(${RESULT_VAR} true CACHE BOOL "Enable C++11 compiler features" FORCE)
+  else ()
+    check_cxx_source_compiles("${CXX11_CODE}" CXX11_COMPILES)
+
+    if (CXX11_COMPILES)
+      set(${RESULT_VAR} true CACHE BOOL "Enable C++11 compiler features" FORCE)
+    else ()
+      set(${RESULT_VAR} false CACHE BOOL "Enable C++11 compiler features" FORCE)
+    endif ()
+  endif ()
+endmacro(target_enable_cxx11)

AMDiS/cmake3/target_enable_hypre.cmake

+macro(target_enable_hypre _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    # MPI is required
+    if (LINK_EXECUTABLE)
+      target_enable_mpi(${_TARGET_} ${_SCOPE_} ON)
+    else ()
+      target_enable_mpi(${_TARGET_} ${_SCOPE_})
+    endif (LINK_EXECUTABLE)
+
+
+    find_file(_HYPRE_H HYPRE.h
+      HINTS ${PETSC_INCLUDE_DIRS})
+
+    if (_HYPRE_H)
+      get_filename_component(HYPRE_INCLUDE_DIRECTORIES ${_HYPRE_H} PATH)
+      target_include_directories(${_TARGET_} ${_SCOPE_} ${HYPRE_INCLUDE_DIRECTORIES})
+    endif (_HYPRE_H)
+
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(_HYPRE_LIB HYPRE
+        HINTS ${PETSC_LIBRARY_DIRS})
+
+      if(_HYPRE_LIB)
+        get_filename_component(HLIB_PATH ${_HYPRE_LIB} PATH)
+        file(GLOB HYPRE_OTHER ${HLIB_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}HYPRE*${CMAKE_SHARED_LIBRARY_SUFFIX})
+        target_link_libraries(${_TARGET_} ${_SCOPE_} ${_HYPRE_LIB} ${HYPRE_OTHER})
+      endif (_HYPRE_LIB)
+
+      # lapack library is required
+      find_library(LAPACK_LIB
+        NAMES lapack flapack
+        HINTS ${LAPACK_DIR}/lib ${PETSC_LIBRARY_DIRS} ${PETSC_DIR}/lib)
+      if (LAPACK_LIB)
+        set(LAPACK_LIBRARIES ${LAPACK_LIB})
+      else (LAPACK_LIB)
+        find_package(LAPACK REQUIRED)
+      endif (LAPACK_LIB)
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${LAPACK_LIBRARIES})
+    endif (LINK_EXECUTABLE OR APPLE)
+
+
+    if (_HYPRE_H AND (NOT LINK_EXECUTABLE OR _HYPRE_LIB OR APPLE))
+      set(HAVE_HYPRE ON)
+      target_compile_definitions(${_TARGET_} ${_SCOPE_} MTL_HAS_HYPRE)
+    else ()
+      set(HAVE_HYPRE OFF)
+    endif ()
+
+endmacro(target_enable_hypre)

AMDiS/cmake3/target_enable_mtl4.cmake

+macro(target_enable_mtl4 _TARGET_ _SCOPE_)
+  if (${ARGC} GREATER 2)
+    set(LINK_EXECUTABLE ON)
+  else ()
+    set(LINK_EXECUTABLE OFF)
+  endif ()
+
+  if (LINK_EXECUTABLE)
+    target_include_directories(${_TARGET_} ${_SCOPE_} ${AMDIS_INCLUDE_DIR}/mtl4)
+  else ()
+    target_include_directories(${_TARGET_} ${_SCOPE_} ${BASE_DIR}/lib/mtl4)
+  endif (LINK_EXECUTABLE)
+  target_compile_definitions(${_TARGET_} ${_SCOPE_} MTL_ASSERT_FOR_THROW=1)
+
+  set (CXX_ELEVEN_FEATURE_LIST "MOVE" "AUTO" "RANGEDFOR" "INITLIST" "STATICASSERT" "DEFAULTIMPL")
+  foreach (feature ${CXX_ELEVEN_FEATURE_LIST})
+    target_compile_definitions(${_TARGET_} ${_SCOPE_} MTL_WITH_${feature})
+  endforeach ()
+
+  if (ENABLE_OPENMP)
+    find_package(OpenMP REQUIRED)
+    target_compile_definitions(${_TARGET_} ${_SCOPE_} MTL_WITH_OPENMP HAVE_OPENMP)
+    target_compile_options(${_TARGET_} ${_SCOPE_} ${OpenMP_CXX_FLAGS})
+  endif (ENABLE_OPENMP)
+endmacro(target_enable_mtl4)

AMDiS/cmake3/target_enable_petsc.cmake

+include(FindPkgConfig)
+
+macro(target_enable_mpi _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    find_package(MPI REQUIRED)
+    target_include_directories(${_TARGET_} ${_SCOPE_}
+      ${MPI_CXX_INCLUDE_PATH})
+    target_compile_options(${_TARGET_} ${_SCOPE_}
+      ${MPI_CXX_COMPILE_FLAGS})
+
+    if (LINK_EXECUTABLE OR APPLE)
+      # the parameter --enable-new-dtags causes a linker problem, i.e. some libraries are
+      # linked without an rpath (or any other path information) and can not be found while
+      # running the executable. The hack below removes this flag manually from the linker flags.
+      string(REPLACE "-Wl,--enable-new-dtags" "" MY_MPI_CXX_LINK_FLAGS " ${MPI_CXX_LINK_FLAGS} ")
+      string(STRIP "${MY_MPI_CXX_LINK_FLAGS}" MY_MPI_CXX_LINK_FLAGS)
+
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${MPI_CXX_LIBRARIES} ${MY_MPI_CXX_LINK_FLAGS})
+    endif (LINK_EXECUTABLE OR APPLE)
+endmacro(target_enable_mpi)
+
+macro(target_enable_petsc _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    # PETSc library is required
+    find_file(PETSC_PKG_CONFIG "PETSc.pc"
+      HINTS ${PETSC_DIR}/lib/pkgconfig
+            $ENV{PETSC_DIR}/lib/pkgconfig
+            ${PETSC_ROOT}/lib/pkgconfig
+            $ENV{PETSC_ROOT}/lib/pkgconfig
+            /usr/lib/petsc/lib/pkgconfig
+            /usr/lib/petsc/linux-gnu-cxx-opt/lib/pkgconfig
+            /usr/lib/petsc/linux-gnu-c-opt/lib/pkgconfig
+      PATHS $ENV{PKG_CONFIG_PATH})
+    if (PETSC_PKG_CONFIG)
+      get_filename_component(PETSC_PKG_CONFIG_PATH "${PETSC_PKG_CONFIG}" PATH CACHE)
+      set(ENV{PKG_CONFIG_PATH} ${PETSC_PKG_CONFIG_PATH})
+      pkg_check_modules(PETSC REQUIRED PETSc>=3.3)
+      set(PETSC_DEFINITIONS ${PETSC_CFLAGS} ${PETSC_CFLAGS_OTHER})
+    endif (PETSC_PKG_CONFIG)
+
+    # check whether PETSc installation and configuration is valid
+    if (NOT PETSC_INCLUDE_DIRS)
+      set(PETSC_VALID OFF)
+    else ()
+      find_file(PETSC_HEADER_FILE "petsc.h" PATHS ${PETSC_INCLUDE_DIRS} NO_DEFAULT_PATH)
+      if (PETSC_HEADER_FILE)
+        set(PETSC_VALID ON)
+      else ()
+        set(PETSC_VALID OFF)
+      endif ()
+    endif (NOT PETSC_INCLUDE_DIRS)
+
+    # if not valid, search again
+    if (NOT PETSC_VALID)
+      message(WARNING "  ---> pkg-config of PETSc is broken!")
+      find_package(PETSc REQUIRED CXX)
+      set(PETSC_INCLUDE_DIRS ${PETSC_INCLUDES})
+      set(PETSC_LIBRARY_DIRS ${PETSC_LIB_DIR})
+      message(STATUS "  Found PETSc, version ${PETSC_VERSION}")
+    endif (NOT PETSC_VALID)
+
+    target_include_directories(${_TARGET_} ${_SCOPE_} ${PETSC_INCLUDE_DIRS})
+    target_compile_definitions(${_TARGET_} ${_SCOPE_}
+        HAVE_PARALLEL_PETSC=1
+        PETSC_VERSION=${PETSC_VERSION})
+    target_compile_options(${_TARGET_} ${_SCOPE_} ${PETSC_DEFINITIONS})
+
+    if (LINK_EXECUTABLE OR APPLE)
+      set(PETSC_LINK_LIBRARIES "")
+      foreach (_PETSC_LIB ${PETSC_LIBRARIES})
+        find_library(_PETSC_LINK_LIB ${_PETSC_LIB} PATHS ${PETSC_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        list(APPEND PETSC_LINK_LIBRARIES ${_PETSC_LINK_LIB})
+      endforeach()
+      message(STATUS "  Found PETSc library ${PETSC_LINK_LIBRARIES}")
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${PETSC_LINK_LIBRARIES})
+    endif (LINK_EXECUTABLE OR APPLE)
+
+
+    # parmetis is required
+    find_file(PARMETIS_HEADER_FILE "parmetis.h"
+      HINTS ${PARMETIS_DIR}/include ${PETSC_INCLUDE_DIRS} /usr/include/parmetis)
+    if (PARMETIS_HEADER_FILE)
+      get_filename_component(PARMETIS_INCLUDE_PATH "${PARMETIS_HEADER_FILE}" PATH CACHE)
+      target_include_directories(${_TARGET_} ${_SCOPE_} ${PARMETIS_INCLUDE_PATH})
+      file(READ ${PARMETIS_HEADER_FILE} PARMETIS_HEADER_FILE_CONTENT)
+
+      string(FIND "${PARMETIS_HEADER_FILE_CONTENT}" "ParMETIS_V3_PartKway"       PARMETIS_PARTKWAY_VALID)
+      string(FIND "${PARMETIS_HEADER_FILE_CONTENT}" "ParMETIS_V3_Mesh2Dual"      PARMETIS_MESH2DUAL_VALID)
+      string(FIND "${PARMETIS_HEADER_FILE_CONTENT}" "ParMETIS_V3_AdaptiveRepart" PARMETIS_ADAPTIVEREPART_VALID)
+      string(FIND "${PARMETIS_HEADER_FILE_CONTENT}" "ParMETIS_V3_RefineKway"     PARMETIS_REFINEKWAYVALID)
+      if (NOT (PARMETIS_PARTKWAY_VALID AND PARMETIS_MESH2DUAL_VALID AND PARMETIS_ADAPTIVEREPART_VALID AND PARMETIS_REFINEKWAYVALID))
+        message(FATAL_ERROR "ParMETIS installation not complete. Not all required symbols found in ${PARMETIS_HEADER_FILE}.")
+      endif ()
+    else()
+      message(FATAL_ERROR "Could not find ParMetis header file 'parmetis.h'!")
+    endif (PARMETIS_HEADER_FILE)
+
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(PARMETIS_LIB parmetis
+        HINTS ${PARMETIS_DIR}/lib ${PETSC_LIBRARY_DIRS})
+      if (NOT PARMETIS_LIB)
+        message(FATAL_ERROR "Could not find the ParMetis libraries needed by amdis")
+      endif (NOT PARMETIS_LIB)
+      message(STATUS "  Found ParMetis library ${PARMETIS_LIB}")
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${PARMETIS_LIB})
+    endif (LINK_EXECUTABLE OR APPLE)
+
+
+    # metis is required
+    find_file(METIS_HEADER_FILE "metis.h"
+      HINTS ${METIS_DIR}/include ${PETSC_INCLUDE_DIRS} /usr/include/metis)
+    if (METIS_HEADER_FILE)
+      get_filename_component(METIS_INCLUDE_PATH "${METIS_HEADER_FILE}" PATH CACHE)
+      target_include_directories(${_TARGET_} ${_SCOPE_} ${METIS_INCLUDE_PATH})
+    else()
+      message(FATAL_ERROR "Could not find Metis header file 'metis.h'!")
+    endif (METIS_HEADER_FILE)
+
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(METIS_LIB metis
+        HINTS ${METIS_DIR}/lib ${PETSC_LIBRARY_DIRS})
+      if (NOT METIS_LIB)
+        message(FATAL_ERROR "Could not find the Metis libraries needed by amdis")
+      endif (NOT METIS_LIB)
+      message(STATUS "  Found Metis library ${METIS_LIB}")
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${METIS_LIB})
+    endif (LINK_EXECUTABLE OR APPLE)
+
+
+    # blas library is required
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(BLAS_LIB
+        NAMES blas fblas openblas
+        HINTS ${BLAS_DIR}/lib ${PETSC_LIBRARY_DIRS} /usr/lib/openblas-base /usr/lib/atlas-base)
+      if (BLAS_LIB)
+        set(BLAS_LIBRARIES ${BLAS_LIB})
+      else (BLAS_LIB)
+        find_package(BLAS REQUIRED)
+      endif (BLAS_LIB)
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${BLAS_LIBRARIES})
+    endif (LINK_EXECUTABLE OR APPLE)
+
+
+    # lapack library is required
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(LAPACK_LIB
+        NAMES lapack flapack
+        HINTS ${LAPACK_DIR}/lib ${PETSC_LIBRARY_DIRS} ${PETSC_DIR}/lib)
+      if (LAPACK_LIB)
+        set(LAPACK_LIBRARIES ${LAPACK_LIB})
+      else (LAPACK_LIB)
+        find_package(LAPACK REQUIRED)
+      endif (LAPACK_LIB)
+      target_link_libraries(${_TARGET_} ${_SCOPE_} ${LAPACK_LIBRARIES})
+    endif (LINK_EXECUTABLE OR APPLE)
+endmacro(target_enable_petsc)

AMDiS/cmake3/target_enable_png.cmake

+macro(target_enable_png _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    find_file(_PNG_H png.h
+      HINTS ENV CPATH /usr/include
+      DOC "headerfile png.h for PNG-READER")
+
+    if (NOT _PNG_H)
+      message(FATAL_ERROR "Could not find the PNG header png.h.")
+    else ()
+      file(STRINGS ${_PNG_H} PNG_VERSION_LINE REGEX "#define PNG_LIBPNG_VER_STRING")
+      string(REGEX MATCH "\"([0-9]+[.][0-9]+([.][0-9]+)?)\"" PNG_VERSION_LINE ${PNG_VERSION_LINE})
+      set(PNG_VERSION ${CMAKE_MATCH_1})
+
+      message(STATUS "Libpng version: ${PNG_VERSION}")
+      if (NOT PNG_VERSION VERSION_LESS "1.6" OR NOT PNG_VERSION VERSION_GREATER "1.2")
+        message(FATAL_ERROR "Incompatible libpng version. Requires 1.2.x")
+      endif ()
+    endif ()
+
+    get_filename_component(PNG_PATH ${_PNG_H} PATH)
+    target_include_directories(${_TARGET_} ${_SCOPE_} ${PNG_PATH})
+
+    if (LINK_EXECUTABLE OR APPLE)
+      find_library(_PNG_LIB png
+        HINTS ENV LIBRARY_PATH
+        DOC "The PNG library")
+      if (_PNG_LIB)
+        target_link_libraries(${_TARGET_} ${_SCOPE_} ${_PNG_LIB})
+      else()
+        message(FATAL_ERROR "Could not find the PNG library")
+      endif()
+    endif (LINK_EXECUTABLE OR APPLE)
+
+    target_compile_definitions(${_TARGET_} ${_SCOPE_} HAVE_PNG=1)
+endmacro(target_enable_png)

AMDiS/cmake3/target_enable_umfpack.cmake

+macro(target_enable_umfpack _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    if (WIN32)
+        set(SuiteSparse_USE_LAPACK_BLAS ON)
+    endif (WIN32)
+
+    if (SuiteSparse_DIR)
+       file(TO_CMAKE_PATH ${SuiteSparse_DIR} SuiteSparse_DIR)
+    endif (SuiteSparse_DIR)
+
+    # try to use a cmake-package of suitesparse
+    find_package(SuiteSparse QUIET HINTS ${AMDIS_SuiteSparse_DIR})
+    if (SuiteSparse_FOUND)
+        message(STATUS "Found SuiteSparse CMake-library")
+        include(${USE_SuiteSparse})
+        if (LINK_EXECUTABLE OR APPLE)
+          target_link_libraries(${_TARGET_} ${_SCOPE_} ${SuiteSparse_LIBRARIES})
+        endif (LINK_EXECUTABLE OR APPLE)
+        target_include_directories(${_TARGET_} ${_SCOPE_} ${SuiteSparse_INCLUDE_DIR} ${SuiteSparse_METIS_INCLUDE_DIR})
+        set(FOUND_SUITESPARSE_LIBS ${SuiteSparse_LIBRARIES})
+    else (SuiteSparse_FOUND)
+        # find umfpack manually by searching for umfpack.h header file
+        find_library(UMFPACK_LIBRARY umfpack
+          HINTS ${AMDIS_UMFPACK_ROOT_DIR}
+          PATHS $ENV{EBROOTSUITESPARSE}
+          PATH_SUFFIXES lib/ lib64/
+	        DOC "Library file for UMFPACK")
+        find_file(UMFPACK_H umfpack.h
+          HINTS ${AMDIS_UMFPACK_ROOT_DIR}/include
+          PATHS /usr/include/suitesparse /usr/include/ufsparse $ENV{EBROOTSUITESPARSE}/include
+	        DOC "Headerfile umfpack.h for UMFPACK")
+
+        if (UMFPACK_H AND UMFPACK_LIBRARY)
+            get_filename_component(UMFPACK_PATH ${UMFPACK_H} PATH)
+            target_include_directories(${_TARGET_} ${_SCOPE_} ${UMFPACK_PATH})
+
+            get_filename_component(UMFPACK_LIB_PATH ${UMFPACK_LIBRARY} PATH)
+            set(FOUND_SUITESPARSE_LIBS ${UMFPACK_LIBRARY})
+
+            # extract root directory from umfpack lib dir
+            set (UMFPACK_ROOT_DIR ${UMFPACK_LIB_PATH}/..)
+            if (NOT EXISTS ${UMFPACK_ROOT_DIR}/include)
+              message(WARNING "directory ${UMFPACK_ROOT_DIR} is not a valid root dir of an umfpack installation.")
+            endif ()
+
+            if (LINK_EXECUTABLE OR APPLE)
+
+              # find all connected libraries
+              find_library(AMD_LIBRARY amd HINTS ${UMFPACK_LIB_PATH})
+
+              find_library(BLAS_LIB
+                NAMES blas fblas openblas
+                HINTS ${BLAS_DIR}/lib ${UMFPACK_LIB_PATH} /usr/lib/openblas-base /usr/lib/atlas-base)
+              if (BLAS_LIB)
+                set(BLAS_LIBRARIES ${BLAS_LIB})
+              else (BLAS_LIB)
+                find_package(BLAS REQUIRED)
+              endif (BLAS_LIB)
+
+              find_library(CHOLMOD_LIBRARY cholmod HINTS ${UMFPACK_LIB_PATH})
+              find_library(COLAMD_LIBRARY colamd HINTS ${UMFPACK_LIB_PATH})
+              find_library(SUITESPARSECONFIG_LIBRARY suitesparseconfig HINTS ${UMFPACK_LIB_PATH})
+              if (AMD_LIBRARY AND BLAS_LIBRARIES)
+                  list(APPEND FOUND_SUITESPARSE_LIBS ${AMD_LIBRARY} ${BLAS_LIBRARIES})
+              endif (AMD_LIBRARY AND BLAS_LIBRARIES)
+              if (CHOLMOD_LIBRARY)
+                  list(APPEND FOUND_SUITESPARSE_LIBS ${CHOLMOD_LIBRARY})
+              endif (CHOLMOD_LIBRARY)
+              if (COLAMD_LIBRARY)
+                  list(APPEND FOUND_SUITESPARSE_LIBS ${COLAMD_LIBRARY})
+              endif (COLAMD_LIBRARY)
+              if (SUITESPARSECONFIG_LIBRARY)
+                  list(APPEND FOUND_SUITESPARSE_LIBS ${SUITESPARSECONFIG_LIBRARY})
+              endif (SUITESPARSECONFIG_LIBRARY)
+
+              target_link_libraries(${_TARGET_} ${_SCOPE_} ${FOUND_SUITESPARSE_LIBS})
+            endif (LINK_EXECUTABLE OR APPLE)
+        else()
+            if (NOT UMFPACK_H)
+              message(FATAL_ERROR "Could not find the UMFPACK header umfpack.h.")
+            endif ()
+            if (NOT UMFPACK_LIBRARY)
+              message(FATAL_ERROR "Could not find the UMFPACK library libumfpack.so")
+            endif ()
+        endif (UMFPACK_H AND UMFPACK_LIBRARY)
+    endif (SuiteSparse_FOUND)
+
+
+    # Check for clock_gettime in librt
+    if (NOT WIN32 AND (LINK_EXECUTABLE OR APPLE))
+      include(CheckLibraryExists)
+      check_library_exists(rt clock_gettime "time.h" HAVE_CLOCK_GETTIME)
+      if (HAVE_CLOCK_GETTIME)
+          target_link_libraries(${_TARGET_} ${_SCOPE_} rt)
+      else ()
+          check_library_exists(c clock_gettime "" HAVE_CLOCK_GETTIME)
+      endif (HAVE_CLOCK_GETTIME)
+    endif (NOT WIN32 AND (LINK_EXECUTABLE OR APPLE))
+
+
+    # collect informations about umfpack version and found libraries
+    if (FOUND_SUITESPARSE_LIBS)
+        find_file(_UMFPACK_H umfpack.h PATHS ${SuiteSparse_INCLUDE_DIR} ${UMFPACK_PATH} NO_DEFAULT_PATH)
+        file(STRINGS ${_UMFPACK_H} UMFPACK_VERSION_LINE REGEX "#define UMFPACK_VERSION")
+        string(REGEX MATCH "\"UMFPACK V?([^\"]+)\"" UMFPACK_VERSION_REGEX ${UMFPACK_VERSION_LINE})
+        set(UMFPACK_VERSION ${CMAKE_MATCH_1})
+        unset(_UMFPACK_H CACHE)
+
+        message(STATUS "UMFPACK version: ${UMFPACK_VERSION}")
+        if (LINK_EXECUTABLE OR APPLE)
+          message(STATUS "Found the following SuiteSparse libraries:")
+          foreach (lib ${FOUND_SUITESPARSE_LIBS})
+              message(STATUS "  ${lib}")
+          endforeach ()
+        endif (LINK_EXECUTABLE OR APPLE)
+    endif (FOUND_SUITESPARSE_LIBS)
+
+    target_compile_definitions(${_TARGET_} ${_SCOPE_}
+        HAVE_UMFPACK=1
+        MTL_HAS_UMFPACK=1)
+
+endmacro(target_enable_umfpack)

AMDiS/cmake3/target_enable_zoltan.cmake

+include(parse_zoltan_makefile)
+macro(target_enable_zoltan _TARGET_ _SCOPE_)
+    if (${ARGC} GREATER 2)
+      set(LINK_EXECUTABLE ON)
+    else ()
+      set(LINK_EXECUTABLE OFF)
+    endif ()
+
+    find_package(Zoltan QUIET)
+    if (Zoltan_FOUND)
+      find_file(ZOLTAN_HEADER_FILE "zoltan.h" PATHS ${Zoltan_INCLUDE_DIRS})
+      target_include_directories(${_TARGET_} ${_SCOPE_} ${Zoltan_INCLUDE_DIRS})
+
+      if (LINK_EXECUTABLE OR APPLE)
+        foreach (LIB_NAME ${Zoltan_LIBRARIES})
+          find_library(_ZOLTAN_LIB ${LIB_NAME} HINTS ${Zoltan_LIBRARY_DIRS})
+          if (NOT _ZOLTAN_LIB)
+            message(FATAL_ERROR "Could not find library \"${LIB_NAME}\" in directories ${Zoltan_LIBRARY_DIRS}!")
+          else ()
+            target_link_libraries(${_TARGET_} ${_SCOPE_} ${_ZOLTAN_LIB})
+          endif ()
+          unset(_ZOLTAN_LIB CACHE)
+        endforeach(LIB_NAME)
+      endif (LINK_EXECUTABLE OR APPLE)
+    else (Zoltan_FOUND)
+      find_file(ZOLTAN_HEADER_FILE "zoltan.h" HINTS ${ZOLTAN_DIR}/include ${PETSC_INCLUDE_DIRS})
+      if (ZOLTAN_HEADER_FILE)
+        get_filename_component(Zoltan_INCLUDE_DIR "${ZOLTAN_HEADER_FILE}" PATH CACHE)
+        target_include_directories(${_TARGET_} ${_SCOPE_} ${Zoltan_INCLUDE_DIR})
+      else()
+        message(FATAL_ERROR "Could not find Zoltan include file 'zoltan.h'!")
+      endif(ZOLTAN_HEADER_FILE)
+
+      if (LINK_EXECUTABLE OR APPLE)
+        find_library(ZOLTAN_LIB zoltan
+          HINTS ${Zoltan_INCLUDE_DIR}/../lib DOC "Full path to the zoltan library")
+        if (NOT ZOLTAN_LIB)
+          message(FATAL_ERROR "Could not find zoltan library!")
+        endif (NOT ZOLTAN_LIB)
+        target_link_libraries(${_TARGET_} ${_SCOPE_} ${ZOLTAN_LIB})
+
+        find_file(ZOLTAN_CONFIG_FILE "Makefile.export.zoltan" HINTS ${Zoltan_INCLUDE_DIR})
+        if (ZOLTAN_CONFIG_FILE)
+          parse_zoltan_makefile(${ZOLTAN_CONFIG_FILE} ${_TARGET_} ${_SCOPE_})
+        else ()
+          message(WARNING "Zoltan configuration file Makefile.export.zoltan not found!")
+        endif ()
+      endif (LINK_EXECUTABLE OR APPLE)
+
+      target_compile_definitions(${_TARGET_} ${_SCOPE_} HAVE_ZOLTAN=1)
+    endif (Zoltan_FOUND)
+
+    if (ZOLTAN_HEADER_FILE)
+      file(STRINGS ${ZOLTAN_HEADER_FILE} ZOLTAN_VERSION_LINE REGEX "#define ZOLTAN_VERSION_NUMBER")
+      string(REGEX MATCH "([0-9]+[.][0-9]+)" ZOLTAN_VERSION_REGEX ${ZOLTAN_VERSION_LINE})
+      set(ZOLTAN_VERSION ${CMAKE_MATCH_1})
+      unset(ZOLTAN_HEADER_FILE CACHE)
+      message(STATUS "Zoltan version: ${ZOLTAN_VERSION}")
+    endif (ZOLTAN_HEADER_FILE)
+endmacro(target_enable_zoltan)