add a FindMUMPS.cmake and FindSCALAPACK.cmake (detects only the netlib scalapack lib for now)

cmake_modules/morse/find/FindMUMPS.cmake

+###
+#
+# @copyright (c) 2009-2014 The University of Tennessee and The University
+#                          of Tennessee Research Foundation.
+#                          All rights reserved.
+# @copyright (c) 2012-2014 Inria. All rights reserved.
+# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+#
+###
+#
+# - Find MUMPS include dirs and libraries
+# Use this module by invoking find_package with the form:
+#  find_package(MUMPS
+#               [REQUIRED]             # Fail with error if mumps is not found
+#               [COMPONENTS <libs>...] # required dependencies
+#              )
+#  COMPONENTS can be one of the following:
+#   MPI: to activate detection of the parallel MPI version (default behaviour)
+#   SEQ: to activate detection of sequential version (exclude MPI version)
+#   SCOTCH: to activate detection of MUMPS linked with SCOTCH
+#   METIS: to activate detection of MUMPS linked with METIS
+# This module finds headers and mumps library.
+# Results are reported in variables:
+#  MUMPS_FOUND           - True if headers and requested libraries were found
+#  MUMPS_INCLUDE_DIRS    - mumps include directories
+#  MUMPS_LIBRARY_DIRS    - Link directories for mumps libraries
+# The user can give specific paths where to find the libraries adding cmake
+# options at configure (ex: cmake path/to/project -DMUMPS_DIR=path/to/mumps):
+#  MUMPS_DIR             - Where to find the base directory of mumps
+#  MUMPS_INCDIR          - Where to find the header files
+#  MUMPS_LIBDIR          - Where to find the library files
+
+#=============================================================================
+# Copyright 2012-2013 Inria
+# Copyright 2012-2013 Emmanuel Agullo
+# Copyright 2012-2013 Mathieu Faverge
+# Copyright 2012      Cedric Castagnede
+# Copyright 2013      Florent Pruvost
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file MORSE-Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of Morse, substitute the full
+#  License text for the above reference.)
+
+
+if (NOT MUMPS_FOUND)
+    set(MUMPS_DIR "" CACHE PATH "Root directory of MUMPS library")
+    if (NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "A cache variable, namely MUMPS_DIR, has been set to specify the install directory of MUMPS")
+    endif()
+endif()
+
+# Try to find MUMPS dependencies if specified as COMPONENTS during the call
+set(MUMPS_LOOK_FOR_SEQ OFF)
+set(MUMPS_LOOK_FOR_MPI ON)
+if( MUMPS_FIND_COMPONENTS )
+    foreach( component ${MUMPS_FIND_COMPONENTS} )
+        if (${component} STREQUAL "SEQ")
+            # means we look for the sequential version of MUMPS (without MPI)
+            set(MUMPS_LOOK_FOR_SEQ ON)
+            set(MUMPS_LOOK_FOR_MPI OFF)
+        endif()
+        if (${component} STREQUAL "MPI")
+            # means we look for the sequential version of MUMPS (without MPI)
+            set(MUMPS_LOOK_FOR_MPI ON)
+            set(MUMPS_LOOK_FOR_SEQ OFF)
+        endif()
+        if (NOT ${component} STREQUAL "SEQ")
+            if(MUMPS_FIND_REQUIRED_${component})
+                find_package(${component} REQUIRED)
+            else()
+                find_package(${component})
+            endif()
+        endif()
+        if(${component}_FOUND)
+            set(MUMPS_${component}_FOUND TRUE)
+            # should we have these variables available in gui modes?
+            if (MPI_FOUND)
+                mark_as_advanced(MPI_LIBRARY)
+                mark_as_advanced(MPI_EXTRA_LIBRARY)
+            endif()
+        else()
+            set(MUMPS_${component}_FOUND FALSE)
+        endif()
+    endforeach()
+endif()
+
+if (NOT MUMPS_FIND_QUIETLY)
+    if (MUMPS_LOOK_FOR_SEQ)
+        message(STATUS "Looking for MUMPS - sequential version (without MPI)")
+    else()
+        message(STATUS "Looking for MUMPS - MPI version -"
+        " if you want to force detection of a sequential "
+        "version use find_package(MUMPS [REQUIRED] COMPONENTS SEQ [...])")
+    endif()
+endif()
+
+if (NOT MUMPS_FIND_QUIETLY)
+    message(STATUS "Looking for MUMPS - PkgConfig not used")
+endif()
+
+# Dependencies detection
+# ----------------------
+
+
+# Required dependencies
+# ---------------------
+
+if (NOT MUMPS_FIND_QUIETLY)
+    message(STATUS "Looking for MUMPS - Try to detect pthread")
+endif()
+if (MUMPS_FIND_REQUIRED)
+    find_package(Threads REQUIRED)
+else()
+    find_package(Threads)
+endif()
+set(MUMPS_EXTRA_LIBRARIES "")
+if( THREADS_FOUND )
+    list(APPEND MUMPS_EXTRA_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
+endif ()
+
+# MUMPS depends on BLAS
+#----------------------
+if (NOT MUMPS_FIND_QUIETLY)
+    message(STATUS "Looking for MUMPS - Try to detect BLAS")
+endif()
+if (MUMPS_FIND_REQUIRED)
+    find_package(BLASEXT REQUIRED)
+else()
+    find_package(BLASEXT)
+endif()
+
+# Optional dependencies
+# ---------------------
+
+# MUMPS may depend on MPI
+#------------------------
+if (NOT MPI_FOUND AND NOT MUMPS_LOOK_FOR_SEQ)
+    if (NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for MUMPS - Try to detect MPI")
+    endif()
+    # allows to use an external mpi compilation by setting compilers with
+    # -DMPI_C_COMPILER=path/to/mpicc -DMPI_Fortran_COMPILER=path/to/mpif90
+    # at cmake configure
+    if(NOT MPI_C_COMPILER)
+        set(MPI_C_COMPILER mpicc)
+    endif()
+    if (MUMPS_FIND_REQUIRED AND MUMPS_LOOK_FOR_MPI)
+        find_package(MPI REQUIRED)
+    else()
+        find_package(MPI)
+    endif()
+    if (MPI_FOUND)
+        mark_as_advanced(MPI_LIBRARY)
+        mark_as_advanced(MPI_EXTRA_LIBRARY)
+    endif()
+endif (NOT MPI_FOUND AND NOT MUMPS_LOOK_FOR_SEQ)
+
+# MUMPS may depend on ScaLAPACK (if MPI version)
+#-----------------------------------------------
+if (NOT SCALAPACK_FOUND AND NOT MUMPS_LOOK_FOR_SEQ)
+    if (NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for MUMPS - Try to detect SCALAPACK")
+    endif()
+    # SCALAPACK is a required dependency if MPI is used
+    if (MUMPS_FIND_REQUIRED AND MUMPS_LOOK_FOR_MPI)
+        find_package(SCALAPACK REQUIRED)
+    else()
+        find_package(SCALAPACK)
+    endif()
+endif (NOT SCALAPACK_FOUND AND NOT MUMPS_LOOK_FOR_SEQ)
+
+# MUMPS may depends on SCOTCH
+#----------------------------
+if (NOT SCOTCH_FOUND)
+    if (NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for MUMPS - Try to detect SCOTCH")
+    endif()
+    if (MUMPS_FIND_REQUIRED AND MUMPS_FIND_REQUIRED_SCOTCH)
+        find_package(SCOTCH REQUIRED)
+    else()
+        find_package(SCOTCH)
+    endif()
+endif()
+
+# MUMPS may depends on METIS
+#---------------------------
+if (NOT METIS_FOUND)
+    if (NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for MUMPS - Try to detect METIS")
+    endif()
+    if (MUMPS_FIND_REQUIRED AND MUMPS_FIND_REQUIRED_METIS)
+        find_package(METIS REQUIRED)
+    else()
+        find_package(METIS)
+    endif()
+endif()
+
+
+# Looking for MUMPS
+# -----------------
+
+# Looking for include
+# -------------------
+
+# Try to find the mumps header in the given path
+# ----------------------------------------------
+# call cmake macro to find the header path
+if(MUMPS_DIR)
+    set(MUMPS_smumps_c.h_DIRS "MUMPS_smumps_c.h_DIRS-NOTFOUND")
+    find_path(MUMPS_smumps_c.h_DIRS
+      NAMES smumps_c.h
+      HINTS ${MUMPS_DIR}
+      PATH_SUFFIXES "include")
+    set(MUMPS_dmumps_c.h_DIRS "MUMPS_dmumps_c.h_DIRS-NOTFOUND")
+    find_path(MUMPS_dmumps_c.h_DIRS
+      NAMES dmumps_c.h
+      HINTS ${MUMPS_DIR}
+      PATH_SUFFIXES "include")
+    set(MUMPS_cmumps_c.h_DIRS "MUMPS_cmumps_c.h_DIRS-NOTFOUND")
+    find_path(MUMPS_cmumps_c.h_DIRS
+      NAMES cmumps_c.h
+      HINTS ${MUMPS_DIR}
+      PATH_SUFFIXES "include")
+    set(MUMPS_zmumps_c.h_DIRS "MUMPS_zmumps_c.h_DIRS-NOTFOUND")
+    find_path(MUMPS_zmumps_c.h_DIRS
+      NAMES zmumps_c.h
+      HINTS ${MUMPS_DIR}
+      PATH_SUFFIXES "include")
+else()
+    if (MUMPS_FIND_REQUIRED)
+        message(FATAL_ERROR "Looking for mumps -- MUMPS_DIR is not set, to find"
+        " MUMPS please set MUMPS_DIR, the path to MUMPS installation where"
+        " sub-directories include/ and lib/ are located")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for mumps -- MUMPS_DIR is not set, to find"
+            " MUMPS please set MUMPS_DIR, the path to MUMPS installation where"
+            " sub-directories include/ and lib/ are located")
+        endif()
+    endif()
+endif()
+
+# If found, add path to cmake variable
+# ------------------------------------
+# detect which precisions are available
+if (MUMPS_smumps_c.h_DIRS)
+    mark_as_advanced(MUMPS_smumps_c.h_DIRS)
+    set(MUMPS_PREC_S ON)
+    set(MUMPS_INCLUDE_DIRS "${MUMPS_smumps_c.h_DIRS}")
+else ()
+    set(MUMPS_PREC_S OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- smumps_c.h not found")
+    endif()
+endif()
+if (MUMPS_dmumps_c.h_DIRS)
+    mark_as_advanced(MUMPS_dmumps_c.h_DIRS)
+    set(MUMPS_PREC_D ON)
+    set(MUMPS_INCLUDE_DIRS "${MUMPS_dmumps_c.h_DIRS}")
+else ()
+    set(MUMPS_PREC_D OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- dmumps_c.h not found")
+    endif()
+endif()
+if (MUMPS_cmumps_c.h_DIRS)
+    mark_as_advanced(MUMPS_cmumps_c.h_DIRS)
+    set(MUMPS_PREC_C ON)
+    set(MUMPS_INCLUDE_DIRS "${MUMPS_cmumps_c.h_DIRS}")
+else ()
+    set(MUMPS_PREC_C OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- cmumps_c.h not found")
+    endif()
+endif()
+if (MUMPS_zmumps_c.h_DIRS)
+    mark_as_advanced(MUMPS_zmumps_c.h_DIRS)
+    set(MUMPS_PREC_Z ON)
+    set(MUMPS_INCLUDE_DIRS "${MUMPS_zmumps_c.h_DIRS}")
+else ()
+    set(MUMPS_PREC_Z OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- zmumps_c.h not found")
+    endif()
+endif()
+
+# Looking for lib
+# ---------------
+
+# Try to find the mumps lib in the given paths
+# --------------------------------------------
+
+# call cmake macro to find the lib path
+if(MUMPS_DIR)
+    set(MUMPS_smumps_LIBRARY "MUMPS_smumps_LIBRARY-NOTFOUND")
+    find_library(MUMPS_smumps_LIBRARY
+                 NAMES smumps
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES lib)
+    set(MUMPS_dmumps_LIBRARY "MUMPS_dmumps_LIBRARY-NOTFOUND")
+    find_library(MUMPS_dmumps_LIBRARY
+                 NAMES dmumps
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES lib)
+    set(MUMPS_cmumps_LIBRARY "MUMPS_cmumps_LIBRARY-NOTFOUND")
+    find_library(MUMPS_cmumps_LIBRARY
+                 NAMES cmumps
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES lib)
+    set(MUMPS_zmumps_LIBRARY "MUMPS_zmumps_LIBRARY-NOTFOUND")
+    find_library(MUMPS_zmumps_LIBRARY
+                 NAMES zmumps
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES lib)
+    set(MUMPS_mumps_common_LIBRARY "MUMPS_mumps_common_LIBRARY-NOTFOUND")
+    find_library(MUMPS_mumps_common_LIBRARY
+                 NAMES mumps_common
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES lib)
+    set(MUMPS_mpiseq_LIBRARY "MUMPS_mpiseq_LIBRARY-NOTFOUND")
+    find_library(MUMPS_mpiseq_LIBRARY
+                 NAMES mpiseq
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES libseq)
+    set(MUMPS_pord_LIBRARY "MUMPS_pord_LIBRARY-NOTFOUND")
+    find_library(MUMPS_pord_LIBRARY
+                 NAMES pord
+                 HINTS ${MUMPS_DIR}
+                 PATH_SUFFIXES lib)
+else()
+    if (MUMPS_FIND_REQUIRED)
+        message(FATAL_ERROR "Looking for mumps -- MUMPS_DIR is not set, to find"
+        " MUMPS please set MUMPS_DIR, the path to MUMPS installation where"
+        " sub-directories include/ and lib/ are located")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for mumps -- MUMPS_DIR is not set, to find"
+            " MUMPS please set MUMPS_DIR, the path to MUMPS installation where"
+            " sub-directories include/ and lib/ are located")
+        endif()
+    endif()
+endif()
+
+# If found, add path to cmake variable
+# ------------------------------------
+set(MUMPS_LIBRARIES "")
+set(MUMPS_LIBRARY_DIRS "")
+# detect which precisions are available
+if (MUMPS_smumps_LIBRARY)
+    mark_as_advanced(MUMPS_smumps_LIBRARY)
+    list(APPEND MUMPS_LIBRARIES "${MUMPS_smumps_LIBRARY}")
+    get_filename_component(smumps_lib_path ${MUMPS_smumps_LIBRARY} PATH)
+    list(APPEND MUMPS_LIBRARY_DIRS "${smumps_lib_path}")
+else ()
+    set(MUMPS_PREC_S OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- libsmumps.a not found")
+    endif()
+endif()
+if (MUMPS_dmumps_LIBRARY)
+    mark_as_advanced(MUMPS_dmumps_LIBRARY)
+    list(APPEND MUMPS_LIBRARIES "${MUMPS_dmumps_LIBRARY}")
+    get_filename_component(dmumps_lib_path ${MUMPS_dmumps_LIBRARY} PATH)
+    list(APPEND MUMPS_LIBRARY_DIRS "${dmumps_lib_path}")
+else ()
+    set(MUMPS_PREC_D OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- libdmumps.a not found")
+    endif()
+endif()
+if (MUMPS_cmumps_LIBRARY)
+    mark_as_advanced(MUMPS_cmumps_LIBRARY)
+    list(APPEND MUMPS_LIBRARIES "${MUMPS_cmumps_LIBRARY}")
+    get_filename_component(cmumps_lib_path ${MUMPS_cmumps_LIBRARY} PATH)
+    list(APPEND MUMPS_LIBRARY_DIRS "${cmumps_lib_path}")
+else ()
+    set(MUMPS_PREC_C OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- libcmumps.a not found")
+    endif()
+endif()
+if (MUMPS_zmumps_LIBRARY)
+    mark_as_advanced(MUMPS_zmumps_LIBRARY)
+    list(APPEND MUMPS_LIBRARIES "${MUMPS_zmumps_LIBRARY}")
+    get_filename_component(zmumps_lib_path ${MUMPS_zmumps_LIBRARY} PATH)
+    list(APPEND MUMPS_LIBRARY_DIRS "${zmumps_lib_path}")
+else ()
+    set(MUMPS_PREC_Z OFF)
+    if(NOT MUMPS_FIND_QUIETLY)
+        message(STATUS "Looking for mumps -- libzmumps.a not found")
+    endif()
+endif()
+list(REMOVE_DUPLICATES MUMPS_LIBRARY_DIRS)
+# check that one precision arithmetic at least has been discovered
+if (NOT MUMPS_PREC_S AND NOT MUMPS_PREC_D AND NOT MUMPS_PREC_C AND NOT MUMPS_PREC_S)
+    if (MUMPS_FIND_REQUIRED)
+        message(FATAL_ERROR "Looking for mumps -- "
+        "no lib[sdcz]mumps.a have been found in ${MUMPS_DIR}/lib when required")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for mumps -- no lib[sdcz]mumps.a have been found")
+        endif()
+    endif()
+endif()
+# other MUMPS libraries
+if (MUMPS_mumps_common_LIBRARY)
+    mark_as_advanced(MUMPS_mumps_common_LIBRARY)
+    list(APPEND MUMPS_LIBRARIES "${MUMPS_mumps_common_LIBRARY}")
+    get_filename_component(mumps_common_lib_path ${MUMPS_mumps_common_LIBRARY} PATH)
+    list(APPEND MUMPS_LIBRARY_DIRS "${mumps_common_lib_path}")
+else ()
+    if (MUMPS_FIND_REQUIRED)
+        message(FATAL_ERROR "Looking for mumps -- "
+        "libmumps_common.a not found in ${MUMPS_DIR}/lib when required")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for mumps -- libmumps_common.a not found")
+        endif()
+    endif()
+endif()
+if (MUMPS_mpiseq_LIBRARY)
+    mark_as_advanced(MUMPS_mpiseq_LIBRARY)
+    if (MUMPS_LOOK_FOR_SEQ)
+        list(APPEND MUMPS_LIBRARIES "${MUMPS_mpiseq_LIBRARY}")
+        get_filename_component(mpiseq_lib_path ${MUMPS_mpiseq_LIBRARY} PATH)
+        list(APPEND MUMPS_LIBRARY_DIRS "${mpiseq_lib_path}")
+    endif()
+else ()
+    if (MUMPS_FIND_REQUIRED AND MUMPS_LOOK_FOR_SEQ)
+        message(FATAL_ERROR "Looking for mumps -- "
+        "libmpiseq.a not found in ${MUMPS_DIR}/libseq when required")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for mumps -- libmpiseq.a not found")
+        endif()
+    endif()
+endif()
+if (MUMPS_pord_LIBRARY)
+    mark_as_advanced(MUMPS_pord_LIBRARY)
+    list(APPEND MUMPS_LIBRARIES "${MUMPS_pord_LIBRARY}")
+    get_filename_component(pord_lib_path ${MUMPS_pord_LIBRARY} PATH)
+    list(APPEND MUMPS_LIBRARY_DIRS "${pord_lib_path}")
+else ()
+    if (MUMPS_FIND_REQUIRED)
+        message(FATAL_ERROR "Looking for mumps -- "
+        "libpord.a not found in ${MUMPS_DIR}/lib when required")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for mumps -- libpord.a not found")
+        endif()
+    endif()
+endif()
+
+
+if(MUMPS_LIBRARIES)
+    # check a function to validate the find
+    if (MUMPS_INCLUDE_DIRS)
+        set(CMAKE_REQUIRED_INCLUDES "${MUMPS_INCLUDE_DIRS}")
+    endif()
+    set(CMAKE_REQUIRED_FLAGS)
+    foreach(libdir ${MUMPS_LIBRARY_DIRS})
+        if (libdir)
+            set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+        endif()
+    endforeach()
+    set(CMAKE_REQUIRED_LIBRARIES "${MUMPS_LIBRARIES}")
+    if (BLAS_FOUND)
+        if (BLAS_INCLUDE_DIRS)
+            list(APPEND CMAKE_REQUIRED_INCLUDES "${BLAS_INCLUDE_DIRS}")
+        endif()
+        foreach(libdir ${BLAS_LIBRARY_DIRS})
+            if (libdir)
+                set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+            endif()
+        endforeach()
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${BLAS_LIBRARIES}")
+    endif()
+    if (SCALAPACK_FOUND AND MUMPS_LOOK_FOR_MPI OR MUMPS_FIND_REQUIRED_MPI)
+        if (SCALAPACK_INCLUDE_DIRS)
+            list(APPEND CMAKE_REQUIRED_INCLUDES "${SCALAPACK_INCLUDE_DIRS}")
+        endif()
+        foreach(libdir ${SCALAPACK_LIBRARY_DIRS})
+            if (libdir)
+                set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+            endif()
+        endforeach()
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${SCALAPACK_LIBRARIES}")
+    endif()
+    if (MPI_FOUND AND MUMPS_LOOK_FOR_MPI OR MUMPS_FIND_REQUIRED_MPI)
+        if (MPI_C_INCLUDE_PATH)
+            list(APPEND CMAKE_REQUIRED_INCLUDES "${MPI_C_INCLUDE_PATH}")
+        endif()
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${MPI_C_LIBRARIES}")
+    endif()
+    if (MUMPS_FIND_REQUIRED_SCOTCH)
+        if (SCOTCH_INCLUDE_DIRS)
+            list(APPEND CMAKE_REQUIRED_INCLUDES "${SCOTCH_INCLUDE_DIRS}")
+        endif()
+        foreach(libdir ${SCOTCH_LIBRARY_DIRS})
+            if (libdir)
+                set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+            endif()
+        endforeach()
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${SCOTCH_LIBRARIES}")
+    endif()
+    if (MUMPS_FIND_REQUIRED_METIS)
+        if (METIS_INCLUDE_DIRS)
+            list(APPEND CMAKE_REQUIRED_INCLUDES "${METIS_INCLUDE_DIRS}")
+        endif()
+        foreach(libdir ${METIS_LIBRARY_DIRS})
+            if (libdir)
+                set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+            endif()
+        endforeach()
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "${METIS_LIBRARIES}")
+    endif()
+    if (CMAKE_Fortran_COMPILER MATCHES ".+gfortran.*")
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "-lgfortran")
+    elseif (CMAKE_Fortran_COMPILER MATCHES ".+ifort.*")
+        list(APPEND CMAKE_REQUIRED_LIBRARIES "-lifcore")
+    endif()
+    list(APPEND CMAKE_REQUIRED_LIBRARIES ${MUMPS_EXTRA_LIBRARIES})
+
+    include(CheckFortranFunctionExists)
+    unset(MUMPS_PREC_S_WORKS CACHE)
+    check_fortran_function_exists(smumps MUMPS_PREC_S_WORKS)
+    mark_as_advanced(MUMPS_PREC_S_WORKS)
+    unset(MUMPS_PREC_D_WORKS CACHE)
+    check_fortran_function_exists(dmumps MUMPS_PREC_D_WORKS)
+    mark_as_advanced(MUMPS_PREC_D_WORKS)
+    unset(MUMPS_PREC_C_WORKS CACHE)
+    check_fortran_function_exists(cmumps MUMPS_PREC_C_WORKS)
+    mark_as_advanced(MUMPS_PREC_C_WORKS)
+    unset(MUMPS_PREC_Z_WORKS CACHE)
+    check_fortran_function_exists(zmumps MUMPS_PREC_Z_WORKS)
+    mark_as_advanced(MUMPS_PREC_Z_WORKS)
+
+    set(MUMPS_WORKS FALSE)
+    if(MUMPS_PREC_S_WORKS OR MUMPS_PREC_D_WORKS OR MUMPS_PREC_C_WORKS OR MUMPS_PREC_Z_WORKS)
+        set(MUMPS_WORKS TRUE)
+    endif()
+
+    if (NOT MUMPS_WORKS)
+        if (SCOTCH_FOUND AND NOT MUMPS_FIND_REQUIRED_SCOTCH)
+            if (SCOTCH_INCLUDE_DIRS)
+                list(APPEND CMAKE_REQUIRED_INCLUDES "${SCOTCH_INCLUDE_DIRS}")
+            endif()
+            foreach(libdir ${SCOTCH_LIBRARY_DIRS})
+                if (libdir)
+                    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+                endif()
+            endforeach()
+            list(APPEND CMAKE_REQUIRED_LIBRARIES "${SCOTCH_LIBRARIES}")
+        endif()
+        check_fortran_function_exists(smumps MUMPS_PREC_S_WORKS)
+        check_fortran_function_exists(dmumps MUMPS_PREC_D_WORKS)
+        check_fortran_function_exists(cmumps MUMPS_PREC_C_WORKS)
+        check_fortran_function_exists(zmumps MUMPS_PREC_Z_WORKS)
+    endif()
+
+    set(MUMPS_WORKS FALSE)
+    if(MUMPS_PREC_S_WORKS OR MUMPS_PREC_D_WORKS OR MUMPS_PREC_C_WORKS OR MUMPS_PREC_Z_WORKS)
+        set(MUMPS_WORKS TRUE)
+    endif()
+
+    if (NOT MUMPS_WORKS)
+        if (METIS_FOUND AND NOT MUMPS_FIND_REQUIRED_METIS)
+            if (METIS_INCLUDE_DIRS)
+                list(APPEND CMAKE_REQUIRED_INCLUDES "${METIS_INCLUDE_DIRS}")
+            endif()
+            foreach(libdir ${METIS_LIBRARY_DIRS})
+                if (libdir)
+                    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -L${libdir}")
+                endif()
+            endforeach()
+            list(APPEND CMAKE_REQUIRED_LIBRARIES "${METIS_LIBRARIES}")
+        endif()
+        check_fortran_function_exists(smumps MUMPS_PREC_S_WORKS)
+        check_fortran_function_exists(dmumps MUMPS_PREC_D_WORKS)
+        check_fortran_function_exists(cmumps MUMPS_PREC_C_WORKS)
+        check_fortran_function_exists(zmumps MUMPS_PREC_Z_WORKS)
+    endif()
+
+    set(MUMPS_WORKS FALSE)
+    if(MUMPS_PREC_S_WORKS OR MUMPS_PREC_D_WORKS OR MUMPS_PREC_C_WORKS OR MUMPS_PREC_Z_WORKS)
+        set(MUMPS_WORKS TRUE)
+    endif()
+
+    if(MUMPS_WORKS)
+        string(REPLACE " -L" ";" CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+        set(MUMPS_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
+        set(MUMPS_LIBRARY_DIRS "${CMAKE_REQUIRED_FLAGS}")
+        set(MUMPS_INCLUDE_DIRS "${CMAKE_REQUIRED_INCLUDES}")
+    else()
+        if(NOT MUMPS_FIND_QUIETLY)
+            message(STATUS "Looking for MUMPS : test of [sdcz]mumps() fails")
+            message(STATUS "MUMPS_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}")
+            message(STATUS "MUMPS_LIBRARY_DIRS: ${CMAKE_REQUIRED_FLAGS}")
+            message(STATUS "MUMPS_INCLUDE_DIRS: ${CMAKE_REQUIRED_INCLUDES}")
+            message(STATUS "Check in CMakeFiles/CMakeError.log to figure out why it fails")
+            message(STATUS "Looking for mumps : set MUMPS_LIBRARIES to NOTFOUND")
+        endif()
+        set(MUMPS_LIBRARIES "MUMPS_LIBRARIES-NOTFOUND")
+    endif()
+    set(CMAKE_REQUIRED_INCLUDES)
+    set(CMAKE_REQUIRED_FLAGS)
+    set(CMAKE_REQUIRED_LIBRARIES)
+endif(MUMPS_LIBRARIES)
+
+
+# check that MUMPS has been found
+# ---------------------------------
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MUMPS DEFAULT_MSG
+                                  MUMPS_LIBRARIES)

cmake_modules/morse/find/FindSCALAPACK.cmake

+###
+#
+# @copyright (c) 2009-2014 The University of Tennessee and The University
+#                          of Tennessee Research Foundation.
+#                          All rights reserved.
+# @copyright (c) 2012-2014 Inria. All rights reserved.
+# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+#
+###
+#
+# - Find SCALAPACK library
+# This module finds an installed fortran library that implements the SCALAPACK
+# linear-algebra interface.
+#
+# This module sets the following variables:
+#  SCALAPACK_FOUND - set to true if a library implementing the SCALAPACK interface
+#    is found
+#  SCALAPACK_LINKER_FLAGS - uncached list of required linker flags (excluding -l
+#    and -L).
+#  SCALAPACK_LIBRARIES - uncached list of libraries (using full path name) to
+#    link against to use SCALAPACK
+#  SCALAPACK95_LIBRARIES - uncached list of libraries (using full path name) to
+#    link against to use SCALAPACK95
+#  SCALAPACK95_FOUND - set to true if a library implementing the SCALAPACK f95
+#    interface is found
+#  BLA_STATIC  if set on this determines what kind of linkage we do (static)
+#  BLA_VENDOR  if set checks only the specified vendor, if not set checks
+#     all the possibilities
+#  BLA_F95     if set on tries to find the f95 interfaces for BLAS/SCALAPACK
+# The user can give specific paths where to find the libraries adding cmake
+# options at configure (ex: cmake path/to/project -DSCALAPACK_DIR=path/to/scalapack):
+#  SCALAPACK_DIR            - Where to find the base directory of scalapack
+#  SCALAPACK_INCDIR         - Where to find the header files
+#  SCALAPACK_LIBDIR         - Where to find the library files
+# Note that if BLAS_DIR is set, it will also look for scalapack in it
+### List of vendors (BLA_VENDOR) valid in this module
+##  Intel(mkl), ACML, Apple, NAS, Generic
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+# Set some colors
+if(NOT WIN32)
+    string(ASCII 27 Esc)
+    set(ColourReset "${Esc}[m")
+    set(ColourBold  "${Esc}[1m")
+    set(Red         "${Esc}[31m")
+    set(Green       "${Esc}[32m")
+    set(Yellow      "${Esc}[33m")
+    set(Blue        "${Esc}[34m")
+    set(Magenta     "${Esc}[35m")
+    set(Cyan        "${Esc}[36m")
+    set(White       "${Esc}[37m")
+    set(BoldRed     "${Esc}[1;31m")
+    set(BoldGreen   "${Esc}[1;32m")
+    set(BoldYellow  "${Esc}[1;33m")
+    set(BoldBlue    "${Esc}[1;34m")
+    set(BoldMagenta "${Esc}[1;35m")
+    set(BoldCyan    "${Esc}[1;36m")
+    set(BoldWhite   "${Esc}[1;37m")
+endif()
+
+## Some macros to print status when search for headers and libs
+# This macro informs why the _lib_to_find file has not been found
+macro(Print_Find_Library_Blas_Status _libname _lib_to_find)
+
+    # save _libname upper/lower case
+    string(TOUPPER ${_libname} LIBNAME)
+    string(TOLOWER ${_libname} libname)
+
+    # print status
+    #message(" ")
+    if(${LIBNAME}_LIBDIR)
+        message("${Yellow}${LIBNAME}_LIBDIR is defined but ${_lib_to_find}"
+                "has not been found in ${ARGN}${ColourReset}")
+    else()
+        if(${LIBNAME}_DIR)
+            message("${Yellow}${LIBNAME}_DIR is defined but ${_lib_to_find}"
+                    "has not been found in ${ARGN}${ColourReset}")
+        else()
+            message("${Yellow}${_lib_to_find} not found."
+                    "Nor ${LIBNAME}_DIR neither ${LIBNAME}_LIBDIR"
+                    "are defined so that we look for ${_lib_to_find} in"
+                    "system paths (Linux: LD_LIBRARY_PATH, Windows: LIB,"
+                    "Mac: DYLD_LIBRARY_PATH,"
+                    "CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES,"
+                    "CMAKE_C_IMPLICIT_LINK_DIRECTORIES)${ColourReset}")
+            if(_lib_env)
+                message("${Yellow}${_lib_to_find} has not been found in"
+                        "${_lib_env}${ColourReset}")
+            endif()
+        endif()
+    endif()
+    message("${BoldYellow}Please indicate where to find ${_lib_to_find}. You have three options:\n"
+            "- Option 1: Provide the root directory of the library with cmake option: -D${LIBNAME}_DIR=your/path/to/${libname}/\n"
+            "- Option 2: Provide the directory where to find the library with cmake option: -D${LIBNAME}_LIBDIR=your/path/to/${libname}/lib/\n"
+            "- Option 3: Update your environment variable (Linux: LD_LIBRARY_PATH, Windows: LIB, Mac: DYLD_LIBRARY_PATH)\n"
+            "- Option 4: If your library provides a PkgConfig file, make sure pkg-config finds your library${ColourReset}")
+
+endmacro()
+
+if (NOT SCALAPACK_FOUND)
+    set(SCALAPACK_DIR "" CACHE PATH "Root directory of SCALAPACK library")
+    if (NOT SCALAPACK_FIND_QUIETLY)
+        message(STATUS "A cache variable, namely SCALAPACK_DIR, has been set to specify the install directory of SCALAPACK")
+    endif()
+endif (NOT SCALAPACK_FOUND)
+
+option(SCALAPACK_VERBOSE "Print some additional information during SCALAPACK
+libraries detection" OFF)
+if (BLAS_VERBOSE)
+    set(SCALAPACK_VERBOSE ON)
+endif ()
+set(_scalapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+
+get_property(_LANGUAGES_ GLOBAL PROPERTY ENABLED_LANGUAGES)
+if (NOT _LANGUAGES_ MATCHES Fortran)
+include(CheckFunctionExists)
+else (NOT _LANGUAGES_ MATCHES Fortran)
+include(CheckFortranFunctionExists)
+endif (NOT _LANGUAGES_ MATCHES Fortran)
+
+set(SCALAPACK_FOUND FALSE)
+set(SCALAPACK95_FOUND FALSE)
+
+# TODO: move this stuff to separate module
+
+macro(Check_Scalapack_Libraries LIBRARIES _prefix _name _flags _list _blaslapack _mpi _threads)
+# This macro checks for the existence of the combination of fortran libraries
+# given by _list.  If the combination is found, this macro checks (using the
+# Check_Fortran_Function_Exists macro) whether can link against that library
+# combination using the name of a routine given by _name using the linker
+# flags given by _flags.  If the combination of libraries is found and passes
+# the link test, LIBRARIES is set to the list of complete library paths that
+# have been found.  Otherwise, LIBRARIES is set to FALSE.
+
+# N.B. _prefix is the prefix applied to the names of all cached variables that
+# are generated internally and marked advanced by this macro.
+
+set(_libraries_work TRUE)
+set(${LIBRARIES})
+set(_combined_name)
+if (NOT _libdir)
+  if (BLAS_DIR)
+    list(APPEND _libdir "${BLAS_DIR}")
+    list(APPEND _libdir "${BLAS_DIR}/lib")
+    if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        list(APPEND _libdir "${BLAS_DIR}/lib64")
+        list(APPEND _libdir "${BLAS_DIR}/lib/intel64")
+    else()
+        list(APPEND _libdir "${BLAS_DIR}/lib32")
+        list(APPEND _libdir "${BLAS_DIR}/lib/ia32")
+    endif()
+  endif ()
+  if (BLAS_LIBDIR)
+    list(APPEND _libdir "${BLAS_LIBDIR}")
+  endif ()
+  if (SCALAPACK_DIR)
+    list(APPEND _libdir "${SCALAPACK_DIR}")
+    list(APPEND _libdir "${SCALAPACK_DIR}/lib")
+    if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+        list(APPEND _libdir "${SCALAPACK_DIR}/lib64")
+        list(APPEND _libdir "${SCALAPACK_DIR}/lib/intel64")
+    else()
+        list(APPEND _libdir "${SCALAPACK_DIR}/lib32")
+        list(APPEND _libdir "${SCALAPACK_DIR}/lib/ia32")
+    endif()
+  endif ()
+  if (SCALAPACK_LIBDIR)
+    list(APPEND _libdir "${SCALAPACK_LIBDIR}")
+  endif ()
+  if (WIN32)
+    string(REPLACE ":" ";" _libdir2 "$ENV{LIB}")
+  elseif (APPLE)
+    string(REPLACE ":" ";" _libdir2 "$ENV{DYLD_LIBRARY_PATH}")
+  else ()
+    string(REPLACE ":" ";" _libdir2 "$ENV{LD_LIBRARY_PATH}")
+  endif ()
+  list(APPEND _libdir "${_libdir2}")
+  list(APPEND _libdir "${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES}")
+  list(APPEND _libdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}")
+endif ()
+
+if (SCALAPACK_VERBOSE)
+    message("${Cyan}Try to find SCALAPACK libraries: ${_list}")
+endif ()
+
+foreach(_library ${_list})
+  set(_combined_name ${_combined_name}_${_library})
+
+  if(_libraries_work)
+    if (BLA_STATIC)
+      if (WIN32)
+        set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
+      endif ( WIN32 )
+      if (APPLE)
+        set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
+      else (APPLE)
+        set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
+      endif (APPLE)
+    else (BLA_STATIC)
+			if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        # for ubuntu's libblas3gf and libscalapack3gf packages
+        set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf)
+      endif ()
+    endif (BLA_STATIC)
+    find_library(${_prefix}_${_library}_LIBRARY
+      NAMES ${_library}
+      HINTS ${_libdir}
+      )
+    mark_as_advanced(${_prefix}_${_library}_LIBRARY)
+    # Print status if not found
+    # -------------------------
+    if (NOT ${_prefix}_${_library}_LIBRARY AND NOT SCALAPACK_FIND_QUIETLY AND SCALAPACK_VERBOSE)
+        Print_Find_Library_Blas_Status(scalapack ${_library} ${_libdir})
+    endif ()
+    set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY})
+    set(_libraries_work ${${_prefix}_${_library}_LIBRARY})
+  endif(_libraries_work)
+endforeach(_library ${_list})
+
+if(_libraries_work)
+  # Test this combination of libraries.
+  if(UNIX AND BLA_STATIC)
+    set(CMAKE_REQUIRED_LIBRARIES ${_flags} "-Wl,--start-group" ${${LIBRARIES}} ${_blaslapack} "-Wl,--end-group" ${_mpi} ${_threads})
+  else(UNIX AND BLA_STATIC)
+    set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_blaslapack} ${_mpi} ${_threads})
+  endif(UNIX AND BLA_STATIC)
+  if (SCALAPACK_VERBOSE)
+      message("${Cyan}SCALAPACK libs found. Try to compile symbol ${_name} with"
+              "following libraries: ${CMAKE_REQUIRED_LIBRARIES}")
+  endif ()
+  if(NOT SCALAPACK_FOUND)
+    unset(${_prefix}${_combined_name}_WORKS CACHE)
+  endif()
+  if (NOT _LANGUAGES_ MATCHES Fortran)
+    check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS)
+  else (NOT _LANGUAGES_ MATCHES Fortran)
+    check_fortran_function_exists(${_name} ${_prefix}${_combined_name}_WORKS)
+  endif (NOT _LANGUAGES_ MATCHES Fortran)
+  set(CMAKE_REQUIRED_LIBRARIES)
+  mark_as_advanced(${_prefix}${_combined_name}_WORKS)
+  set(_libraries_work ${${_prefix}${_combined_name}_WORKS})
+endif(_libraries_work)
+
+ if(_libraries_work)
+   set(${LIBRARIES} ${${LIBRARIES}} ${_blaslapack} ${_mpi} ${_threads})
+ else(_libraries_work)
+    set(${LIBRARIES} FALSE)
+ endif(_libraries_work)
+
+endmacro(Check_Scalapack_Libraries)
+
+
+set(SCALAPACK_LINKER_FLAGS)
+set(SCALAPACK_LIBRARIES)
+set(SCALAPACK95_LIBRARIES)
+
+if (NOT BLAS_FOUND)
+    if(SCALAPACK_FIND_QUIETLY OR NOT SCALAPACK_FIND_REQUIRED)
+        find_package(BLAS)
+    else()
+        find_package(BLAS REQUIRED)
+    endif()
+endif ()
+
+if (NOT LAPACK_FOUND)
+    if(SCALAPACK_FIND_QUIETLY OR NOT SCALAPACK_FIND_REQUIRED)
+        find_package(LAPACK)
+    else()
+        find_package(LAPACK REQUIRED)
+    endif()
+endif ()
+
+if (NOT MPI_FOUND)
+    if(SCALAPACK_FIND_QUIETLY OR NOT SCALAPACK_FIND_REQUIRED)
+        find_package(MPI)
+    else()
+        find_package(MPI REQUIRED)
+    endif()
+endif ()
+
+if(BLAS_FOUND AND LAPACK_FOUND AND MPI_FOUND)
+  set(SCALAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS})
+  list(APPEND SCALAPACK_LINKER_FLAGS ${LAPACK_LINKER_FLAGS})
+  if ($ENV{BLA_VENDOR} MATCHES ".+")
+    set(BLA_VENDOR $ENV{BLA_VENDOR})
+  else ($ENV{BLA_VENDOR} MATCHES ".+")
+    if(NOT BLA_VENDOR)
+      set(BLA_VENDOR "All")
+    endif(NOT BLA_VENDOR)
+  endif ($ENV{BLA_VENDOR} MATCHES ".+")
+
+# Generic SCALAPACK library
+if (BLA_VENDOR STREQUAL "Generic" OR
+    BLA_VENDOR STREQUAL "All")
+  if ( NOT SCALAPACK_LIBRARIES )
+    check_scalapack_libraries(
+    SCALAPACK_LIBRARIES
+    SCALAPACK
+    pdgemm
+    ""
+    "scalapack" # scalapack lib to look for
+    "${LAPACK_LIBRARIES};${BLAS_LIBRARIES}" # blas and lapack libs
+    "${MPI_Fortran_LIBRARIES}" # mpi libs
+    ""          # threads libs
+    )
+  endif ( NOT SCALAPACK_LIBRARIES )
+endif ()
+#intel scalapack
+#if (BLA_VENDOR MATCHES "Intel" OR BLA_VENDOR STREQUAL "All")
+#  if (NOT WIN32)
+#    set(LM "-lm")
+#  endif ()
+#  if (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX)
+#    if(SCALAPACK_FIND_QUIETLY OR NOT SCALAPACK_FIND_REQUIRED)
+#      find_PACKAGE(Threads)
+#    else()
+#      find_package(Threads REQUIRED)
+#    endif()
+#
+#    set(SCALAPACK_SEARCH_LIBS "")
+#
+#    if (BLA_F95)
+#      set(SCALAPACK_mkl_SEARCH_SYMBOL "PDGEMM")
+#      set(_LIBRARIES SCALAPACK95_LIBRARIES)
+#      set(_BLAS_LIBRARIES ${BLAS95_LIBRARIES})
+#      list(APPEND SCALAPACK_SEARCH_LIBS "mkl_scalapack_lp64")
+#    else()
+#      set(SCALAPACK_mkl_SEARCH_SYMBOL "pdgemm")
+#      set(_LIBRARIES SCALAPACK_LIBRARIES)
+#      set(_BLAS_LIBRARIES ${BLAS_LIBRARIES})
+#      list(APPEND SCALAPACK_SEARCH_LIBS "mkl_scalapack_lp64")
+#    endif()
+#
+    # First try empty scalapack libs
+#    if (NOT ${_LIBRARIES})
+#      check_scalapack_libraries(
+#        ${_LIBRARIES}
+#        BLAS
+#        ${SCALAPACK_mkl_SEARCH_SYMBOL}
+#        ""
+#        ""
+#        "${_BLAS_LIBRARIES}"
+#        "mkl_blacs_intelmpi_lp64"
+#        "${CMAKE_THREAD_LIBS_INIT};${LM}"
+#        )
+#    endif ()
+    # Then try the search libs
+#    foreach (IT ${SCALAPACK_SEARCH_LIBS})
+#      if (NOT ${_LIBRARIES})
+#        check_scalapack_libraries(
+#          ${_LIBRARIES}
+#          BLAS
+#          ${SCALAPACK_mkl_SEARCH_SYMBOL}
+#          ""
+#          "${IT}"
+#          "${_BLAS_LIBRARIES}"
+#          "mkl_blacs_intelmpi_lp64"
+#          "${CMAKE_THREAD_LIBS_INIT};${LM}"
+#          )
+#      endif ()
+#    endforeach ()
+#  endif ()
+#endif()
+else(BLAS_FOUND AND LAPACK_FOUND AND MPI_FOUND)
+  message(STATUS "SCALAPACK requires BLAS, LAPACK, and MPI")
+endif(BLAS_FOUND AND LAPACK_FOUND AND MPI_FOUND)
+
+if(BLA_F95)
+ if(SCALAPACK95_LIBRARIES)
+  set(SCALAPACK95_FOUND TRUE)
+ else(SCALAPACK95_LIBRARIES)
+  set(SCALAPACK95_FOUND FALSE)
+ endif(SCALAPACK95_LIBRARIES)
+ if(NOT SCALAPACK_FIND_QUIETLY)
+  if(SCALAPACK95_FOUND)
+    message(STATUS "A library with SCALAPACK95 API found.")
+    message(STATUS "SCALAPACK_LIBRARIES ${SCALAPACK_LIBRARIES}")
+  else(SCALAPACK95_FOUND)
+    message(WARNING "BLA_VENDOR has been set to ${BLA_VENDOR} but SCALAPACK 95 libraries could not be found or check of symbols failed."
+        "\nPlease indicate where to find SCALAPACK libraries. You have three options:\n"
+        "- Option 1: Provide the root directory of SCALAPACK library with cmake option: -DSCALAPACK_DIR=your/path/to/scalapack\n"
+        "- Option 2: Provide the directory where to find BLAS libraries with cmake option: -DBLAS_LIBDIR=your/path/to/blas/libs\n"
+        "- Option 3: Update your environment variable (Linux: LD_LIBRARY_PATH, Windows: LIB, Mac: DYLD_LIBRARY_PATH)\n"
+        "\nTo follow libraries detection more precisely you can activate a verbose mode with -DSCALAPACK_VERBOSE=ON at cmake configure."
+        "\nYou could also specify a BLAS vendor to look for by setting -DBLA_VENDOR=blas_vendor_name."
+        "\nList of possible BLAS vendor: Goto, ATLAS PhiPACK, CXML, DXML, SunPerf, SCSL, SGIMATH, IBMESSL, Intel10_32 (intel mkl v10 32 bit),"
+        "Intel10_64lp (intel mkl v10 64 bit, lp thread model, lp64 model), Intel10_64lp_seq (intel mkl v10 64 bit, sequential code, lp64 model),"
+        "Intel( older versions of mkl 32 and 64 bit), ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic")
+    if(SCALAPACK_FIND_REQUIRED)
+      message(FATAL_ERROR
+      "A required library with SCALAPACK95 API not found. Please specify library location."
+      )
+    else(SCALAPACK_FIND_REQUIRED)
+      message(STATUS
+      "A library with SCALAPACK95 API not found. Please specify library location."
+      )
+    endif(SCALAPACK_FIND_REQUIRED)
+  endif(SCALAPACK95_FOUND)
+ endif(NOT SCALAPACK_FIND_QUIETLY)
+ set(SCALAPACK_FOUND "${SCALAPACK95_FOUND}")
+ set(SCALAPACK_LIBRARIES "${SCALAPACK95_LIBRARIES}")
+else(BLA_F95)
+ if(SCALAPACK_LIBRARIES)
+  set(SCALAPACK_FOUND TRUE)
+ else(SCALAPACK_LIBRARIES)
+  set(SCALAPACK_FOUND FALSE)
+ endif(SCALAPACK_LIBRARIES)
+
+ if(NOT SCALAPACK_FIND_QUIETLY)
+  if(SCALAPACK_FOUND)
+    message(STATUS "A library with SCALAPACK API found.")
+    message(STATUS "SCALAPACK_LIBRARIES ${SCALAPACK_LIBRARIES}")
+  else(SCALAPACK_FOUND)
+    message(WARNING "BLA_VENDOR has been set to ${BLA_VENDOR} but SCALAPACK libraries could not be found or check of symbols failed."
+        "\nPlease indicate where to find SCALAPACK libraries. You have three options:\n"
+        "- Option 1: Provide the root directory of SCALAPACK library with cmake option: -DSCALAPACK_DIR=your/path/to/scalapack\n"
+        "- Option 2: Provide the directory where to find BLAS libraries with cmake option: -DBLAS_LIBDIR=your/path/to/blas/libs\n"
+        "- Option 3: Update your environment variable (Linux: LD_LIBRARY_PATH, Windows: LIB, Mac: DYLD_LIBRARY_PATH)\n"
+        "\nTo follow libraries detection more precisely you can activate a verbose mode with -DSCALAPACK_VERBOSE=ON at cmake configure."
+        "\nYou could also specify a BLAS vendor to look for by setting -DBLA_VENDOR=blas_vendor_name."
+        "\nList of possible BLAS vendor: Goto, ATLAS PhiPACK, CXML, DXML, SunPerf, SCSL, SGIMATH, IBMESSL, Intel10_32 (intel mkl v10 32 bit),"
+        "Intel10_64lp (intel mkl v10 64 bit, lp thread model, lp64 model), Intel10_64lp_seq (intel mkl v10 64 bit, sequential code, lp64 model),"
+        "Intel( older versions of mkl 32 and 64 bit), ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic")
+    if(SCALAPACK_FIND_REQUIRED)
+      message(FATAL_ERROR
+      "A required library with SCALAPACK API not found. Please specify library location."
+      )
+    else(SCALAPACK_FIND_REQUIRED)
+      message(STATUS
+      "A library with SCALAPACK API not found. Please specify library location."
+      )
+    endif(SCALAPACK_FIND_REQUIRED)
+  endif(SCALAPACK_FOUND)
+ endif(NOT SCALAPACK_FIND_QUIETLY)
+endif(BLA_F95)
+
+set(CMAKE_FIND_LIBRARY_SUFFIXES ${_scalapack_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})