target_include_directories(pips-ipmpp PRIVATE ./)
target_include_directories(pips-ipmpp PRIVATE
        ./
        BiCGStabSolver
        CGSolver
        DensePSDSolver
        DenseSymmetricIndefinitSolver
        PCGSolver
        Preconditioners
    )

target_sources(pips-ipmpp
        PRIVATE
            ${CMAKE_CURRENT_SOURCE_DIR}/DoubleLinearSolver.C
            ${CMAKE_CURRENT_SOURCE_DIR}/BiCGStabSolver/BiCGStabSolver.C
            ${CMAKE_CURRENT_SOURCE_DIR}/CGSolver/CGSolver.C
            ${CMAKE_CURRENT_SOURCE_DIR}/DensePSDSolver/DeSymPSDSolver.C
            ${CMAKE_CURRENT_SOURCE_DIR}/DenseSymmetricIndefinitSolver/DeSymIndefSolver.C
            ${CMAKE_CURRENT_SOURCE_DIR}/DenseSymmetricIndefinitSolver/DeSymIndefSolverRoot.C
            ${CMAKE_CURRENT_SOURCE_DIR}/DenseSymmetricIndefinitSolver/DeSymIndefSolver2.C
            ${CMAKE_CURRENT_SOURCE_DIR}/DenseSymmetricIndefinitSolver/DeSymIndefSolver2Root.C
            ${CMAKE_CURRENT_SOURCE_DIR}/PCGSolver/PCGSolver.C
            ${CMAKE_CURRENT_SOURCE_DIR}/Preconditioners/SCsparsifier.C
        )

if (HAVE_MUMPS)
    add_library(mumps_solver STATIC MumpsSolver/MumpsSolverBase.C MumpsSolver/MumpsSolverLeaf.C MumpsSolver/MumpsSolverRoot.C)
    target_include_directories(mumps_solver PRIVATE ${MUMPS_INCLUDE_DIR})
    target_link_libraries(mumps_solver PRIVATE ${MUMPS_D_LIBRARY})

    target_include_directories(pips-ipmpp PRIVATE ${MUMPS_INCLUDE_DIR})
    target_sources(pips-ipmpp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../KKTFormulation/LinearSystems/sLinsysLeafMumps.C)
    target_include_directories(pips-ipmpp PRIVATE MumpsSolver)
    target_compile_definitions(pips-ipmpp PRIVATE -DWITH_MUMPS)

    list(APPEND lin_solvers_list "mumps_solver")
    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)
endif (HAVE_MUMPS)

target_sources(pips-ipmpp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Mc30Scaler/Mc30Scaler.C ${CMAKE_CURRENT_SOURCE_DIR}/Ma27Solver/Ma27Solver.C ${CMAKE_CURRENT_SOURCE_DIR}/Ma27Solver/Ma27SolverRoot.C)
target_include_directories(pips-ipmpp PRIVATE Mc30Scaler Ma27Solver)
if (HAVE_MA27)
    target_compile_definitions(pips-ipmpp PRIVATE -DWITH_MA27)

    if(MA27_LIBRARY)
        list(APPEND lin_solvers_list ${MA27_LIBRARY} ${CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES})
    else(MA27_LIBRARY)
        target_sources(pips-ipmpp PRIVATE ${ma27src})
    endif(MA27_LIBRARY)

    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)
endif (HAVE_MA27)
if (HAVE_MC30)
    target_compile_definitions(pips-ipmpp PRIVATE -DWITH_MC30)

    if(MC30_LIBRARY)
        list(APPEND lin_solvers_list ${MC30_LIBRARY} ${CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES})
    else(MC30_LIBRARY)
        target_sources(pips-ipmpp PRIVATE ${mc30src})
    endif(MC30_LIBRARY)

    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)
endif (HAVE_MC30)

target_sources(pips-ipmpp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/Ma57Solver/Ma57Solver.C ${CMAKE_CURRENT_SOURCE_DIR}/Ma57Solver/Ma57SolverRoot.C)
target_include_directories(pips-ipmpp PRIVATE Ma57Solver)
if (HAVE_MA57)
    target_compile_definitions(pips-ipmpp PRIVATE -DWITH_MA57)

    if(MA57_LIBRARY)
        list(APPEND lin_solvers_list ${MA57_LIBRARY} ${CMAKE_Fortran_IMPLICIT_LINK_LIBRARIES})
    else(MA57_LIBRARY)
        # have ma57 in separate lib, so we can define the renaming of the metis functions only for these source files
        # (older ma57 call metis_nodend/METIS_NODEND, newer ones call hsl_metis)
        # and so it will be target of --exclude-libs,ALL when linking pips-ipmpp library
        add_library(ma57 STATIC ${ma57src})
        target_compile_definitions(ma57 PRIVATE METIS_NODEND=PIPSMETIS_NODEND metis_nodend=pipsmetis_nodend hsl_metis=pipsmetis_nodend)
        set_target_properties(ma57 PROPERTIES Fortran_PREPROCESS ON)
        list(APPEND lin_solvers_list "ma57")

        # provide the pipsmetis_nodend symbol for ma57
        # again as separate lib, to get it behind ma57 in the linker flags
        add_library(metis_adapter STATIC ${CMAKE_CURRENT_SOURCE_DIR}/MetisAdapter.c)
        list(APPEND lin_solvers_list "metis_adapter")
        if(HAVE_METIS)
            target_compile_definitions(metis_adapter PRIVATE -DWITH_METIS)
            list(APPEND lin_solvers_list ${METIS_LIBRARY})
        endif(HAVE_METIS)
    endif(MA57_LIBRARY)

    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)
endif (HAVE_MA57)

if (HAVE_PARDISO OR HAVE_MKL_PARDISO)
    add_library(pardiso_abstract STATIC
            PardisoSolver/PardisoSolver/PardisoSolver.C
            PardisoSolver/PardisoSchurSolver/PardisoSchurSolver.C
            PardisoSolver/PardisoIndefSolver/PardisoIndefSolver.C
            )

    target_include_directories(pips-ipmpp PRIVATE
            PardisoSolver/PardisoSolver
            PardisoSolver/PardisoSchurSolver
            PardisoSolver/PardisoIndefSolver
            )

    list(APPEND lin_solvers_list "pardiso_abstract")
    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)

    target_sources(pips-ipmpp PRIVATE
            ${CMAKE_CURRENT_SOURCE_DIR}/../KKTFormulation/LinearSystems/sLinsysLeafSchurSlv.C
            )

endif (HAVE_PARDISO OR HAVE_MKL_PARDISO)

if (HAVE_PARDISO)
    add_library(pardiso_solver STATIC
            PardisoSolver/PardisoSolver/PardisoPanuaSolver.C
            PardisoSolver/PardisoIndefSolver/PardisoPanuaIndefSolver.C
            PardisoSolver/PardisoSchurSolver/PardisoPanuaSchurSolver.C
            )
    set_target_properties(pardiso_solver PROPERTIES CXX_VISIBILITY_PRESET hidden)
    target_link_libraries(pardiso_solver
            PRIVATE pardiso_abstract
            PRIVATE ${PARDISO_LIBRARY}
            PRIVATE ${MATH_LIBS}
            PRIVATE gfortran
            PRIVATE pthread
            PRIVATE m
            )
    target_compile_definitions(pips-ipmpp PRIVATE -DWITH_PARDISO)
    list(APPEND lin_solvers_list "pardiso_solver")
    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)
endif (HAVE_PARDISO)

if (HAVE_MKL_PARDISO)
    add_library(pardiso_mkl_solver STATIC
            PardisoSolver/PardisoSolver/PardisoMKLSolver.C
            PardisoSolver/PardisoSchurSolver/PardisoMKLSchurSolver.C
            PardisoSolver/PardisoIndefSolver/PardisoMKLIndefSolver.C
            )
    target_link_libraries(pardiso_mkl_solver PRIVATE pardiso_abstract PRIVATE ${MKL_PARDISO_LIBS})
    target_include_directories(pardiso_mkl_solver PRIVATE ${MKL_INCLUDE_DIR})
    target_compile_definitions(pips-ipmpp PRIVATE -DWITH_MKL_PARDISO)

    list(APPEND lin_solvers_list "pardiso_mkl_solver")
    set(lin_solvers_list ${lin_solvers_list} PARENT_SCOPE)
endif (HAVE_MKL_PARDISO)
