changed: some refactoring of the buildsystem

the flags are available as

IFEM_BUILD_CXX_FLAGS (for building the library)
IFEM_CXX_FLAGS for applications (only hold those used in IFEM headers)

this means that applications can only do FIND_PACKAGE(IFEM REQUIRED)
and everything will be available, no mocking around with dependency
libraries required

!NOTE! this changes the names of some of the cmake options !NOTE!
see cmake/Modules/IFEMOptions.cmake for the new names and default values

git-svn-id: http://svn.sintef.no/trondheim/IFEM/trunk@1701 e10b68d5-8a6e-419e-a041-bce267b0401d

Apps/FiniteDefElasticity/CMakeLists.txt

@@ -30,120 +30,10 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
                       ${PROJECT_SOURCE_DIR}/../../cmake/Modules
                       $ENV{HOME}/cmake/Modules)
 
-ENABLE_LANGUAGE(Fortran)
-IF(CMAKE_Fortran_COMPILER MATCHES ifort)
-  SET(LANGUAGE_LIBS -lifcore)
-ENDIF(CMAKE_Fortran_COMPILER MATCHES ifort)
-
-ENABLE_LANGUAGE(CXX)
-IF(CMAKE_CXX_COMPILER MATCHES icpc)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_MKL")
-ELSE(CMAKE_CXX_COMPILER MATCHES icpc)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CBLAS")
-ENDIF(CMAKE_CXX_COMPILER MATCHES icpc)
-
 # Required packages
-FIND_PACKAGE(GoTools REQUIRED)
-FIND_PACKAGE(GoTrivariate REQUIRED)
-FIND_PACKAGE(LAPACK REQUIRED)
-FIND_PACKAGE(ARPACK REQUIRED)
 FIND_PACKAGE(IFEM REQUIRED)
 
-# Optional packages
-IF(NOT "${DISABLE_LRSPLINE}")
-  FIND_PACKAGE(LRSpline)
-ENDIF(NOT "${DISABLE_LRSPLINE}")
-
-IF(${ENABLE_PETSC})
-  FIND_PACKAGE(Petsc)
-ENDIF(${ENABLE_PETSC})
-
-IF(NOT "${DISABLE_SUPERLU}")
-  FIND_PACKAGE(SuperLU)
-ENDIF(NOT "${DISABLE_SUPERLU}")
-
-IF(${ENABLE_SPR})
-  FIND_PACKAGE(SPR)
-ENDIF(${ENABLE_SPR})
-
-IF(${ENABLE_SAMG})
-  FIND_PACKAGE(SAMG)
-ENDIF(${ENABLE_SAMG})
-
-FIND_PACKAGE(VTFWriter)
-
-IF(VTFAPI GREATER 1)
-  SET(IFEM_LIBRARIES -Wl,--whole-archive ${IFEM_LIBRARIES} -Wl,--no-whole-archive)
-ENDIF(VTFAPI GREATER 1)
-
-IF(NOT "${DISABLE_HDF5}")
-  FIND_PACKAGE(HDF5)
-ENDIF(NOT "${DISABLE_HDF5}")
-
-IF(NOT "${DISABLE_OPENMP}")
-  FIND_PACKAGE(OpenMP)
-ENDIF(NOT "${DISABLE_OPENMP}")
-
-IF(OPENMP_FOUND)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -DUSE_OPENMP")
-ENDIF(OPENMP_FOUND)
-
-# Required libraries
-SET(DEPLIBS ${IFEM_LIBRARIES}
-  ${GoTrivariate_LIBRARIES} ${GoTools_LIBRARIES}
-  ${ARPACK_LIBRARIES} ${LAPACK_LIBRARIES}
-  ${LANGUAGE_LIBS}
-)
-
-# Optional libraries
-IF(LRSpline_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${LRSpline_LIBRARIES})
-ENDIF(LRSpline_LIBRARIES)
-
-IF(SuperLU_MT_LIBRARIES AND "${ENABLE_SUPERLU_MT}")
-  FIND_PACKAGE(Threads REQUIRED)
-  SET(DEPLIBS ${DEPLIBS} ${SuperLU_MT_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-ELSEIF(SuperLU_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${SuperLU_LIBRARIES})
-ENDIF(SuperLU_MT_LIBRARIES AND "${ENABLE_SUPERLU_MT}")
-
-IF(PETSC_LIBRARIES)
-  FIND_PACKAGE(SLEPc)
-  IF(SLEPC_LIBRARIES)
-    SET(DEPLIBS ${DEPLIBS} ${SLEPC_LIBRARIES})
-  ENDIF(SLEPC_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${PETSC_LIBRARIES})
-  IF(${ENABLE_PARALLEL_PETSC})
-    FIND_PACKAGE(MPI REQUIRED)
-    SET(DEPLIBS ${DEPLIBS} ${MPI_LIBRARIES})
-  ENDIF(${ENABLE_PARALLEL_PETSC})
-ENDIF(PETSC_LIBRARIES)
-
-IF(SPR_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${SPR_LIBRARIES})
-ENDIF(SPR_LIBRARIES)
-
-IF(SAMG_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${SAMG_LIBRARIES})
-ENDIF(SAMG_LIBRARIES)
-
-IF(VTFWRITER_LIBRARIES)
-  IF(VTFAPI GREATER 1)
-    SET(VTFWRITER_LIBRARIES -Wl,--whole-archive ${VTFWRITER_LIBRARIES} -Wl,--no-whole-archive)
-  ENDIF(VTFAPI GREATER 1)
-  SET(DEPLIBS ${DEPLIBS} ${VTFWRITER_LIBRARIES})
-ENDIF(VTFWRITER_LIBRARIES)
-
-IF(HDF5_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${HDF5_LIBRARIES})
-ENDIF(HDF5_LIBRARIES)
-
-# MKL (when using the Intel compilers)
-IF(CMAKE_CXX_COMPILER MATCHES icpc)
-  FIND_PACKAGE(MKL REQUIRED)
-  SET(DEPLIBS ${DEPLIBS} ${MKL_LIBRARIES})
-  SET(INCLUDES ${INCLUDES} ${MKL_INCLUDES})
-ENDIF(CMAKE_CXX_COMPILER MATCHES icpc)
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${IFEM_CXX_FLAGS}")
 
 INCLUDE_DIRECTORIES(${IFEM_INCLUDES} ${PROJECT_SOURCE_DIR}/../LinearElasticity)
 
@@ -161,7 +51,7 @@ FILE(GLOB_RECURSE NonLinEl_SRCS
   ${PROJECT_SOURCE_DIR}/*.[Cf])
 
 ADD_EXECUTABLE(NonLinEl ${NonLinEl_SRCS})
-TARGET_LINK_LIBRARIES(NonLinEl ${DEPLIBS})
+TARGET_LINK_LIBRARIES(NonLinEl ${IFEM_LIBRARIES})
 
 ADD_CUSTOM_TARGET(doc doxygen 
                   WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}

CMakeLists.txt

@@ -9,19 +9,6 @@ IF(VERBOSE_DEBUG GREATER 0)
   SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSP_DEBUG=${VERBOSE_DEBUG}")
 ENDIF(VERBOSE_DEBUG GREATER 0)
 
-ENABLE_LANGUAGE(Fortran)
-IF(CMAKE_Fortran_COMPILER MATCHES ifort)
-  SET(LANGUAGE_LIBS -lifcore)
-ENDIF(CMAKE_Fortran_COMPILER MATCHES ifort)
-
-ENABLE_LANGUAGE(CXX)
-IF(CMAKE_CXX_COMPILER MATCHES icpc)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_MKL -mkl=sequential")
-ELSE(CMAKE_CXX_COMPILER MATCHES icpc)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_CBLAS")
-  FIND_PACKAGE(LAPACK REQUIRED)
-ENDIF(CMAKE_CXX_COMPILER MATCHES icpc)
-
 ENABLE_TESTING()
 
 CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/scripts/regtest.sh.in
@@ -31,50 +18,12 @@ CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/scripts/regtest.sh.in
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
                       ${CMAKE_SOURCE_DIR}/cmake/Modules)
 
-# Required packages
-FIND_PACKAGE(GoTools REQUIRED)
-FIND_PACKAGE(GoTrivariate REQUIRED)
-FIND_PACKAGE(ARPACK REQUIRED)
-
-# Mimimum GoTools version
-IF(GoTools_VERSION_MAJOR LESS 3 OR NOT GoTools_VERSION_MAJOR)
-  MESSAGE(FATAL_ERROR "GoTools >= 3.0.0 required. bailing")
-ENDIF(GoTools_VERSION_MAJOR LESS 3 OR NOT GoTools_VERSION_MAJOR)
-
-# Optional packages
-IF(${ENABLE_PETSC})
-  FIND_PACKAGE(Petsc)
-ENDIF(${ENABLE_PETSC})
-IF(NOT "${DISABLE_SUPERLU}")
-  FIND_PACKAGE(SuperLU)
-ENDIF(NOT "${DISABLE_SUPERLU}")
-IF(${ENABLE_SPR})
-  FIND_PACKAGE(SPR)
-ENDIF(${ENABLE_SPR})
-IF(${ENABLE_SAMG})
-  FIND_PACKAGE(SAMG)
-ENDIF(${ENABLE_SAMG})
-FIND_PACKAGE(VTFWriter)
-IF(NOT "${DISABLE_HDF5}")
-  FIND_PACKAGE(HDF5)
-ENDIF(NOT "${DISABLE_HDF5}")
-IF(NOT "${DISABLE_LRSPLINE}")
-  FIND_PACKAGE(LRSpline)
-ENDIF(NOT "${DISABLE_LRSPLINE}")
-IF(NOT "${DISABLE_OPENMP}")
-  FIND_PACKAGE(OpenMP)
-ENDIF(NOT "${DISABLE_OPENMP}")
-
-# Required libraries
-SET(DEPLIBS ${GoTrivariate_LIBRARIES} ${GoTools_LIBRARIES}
-            ${ARPACK_LIBRARIES} ${LAPACK_LIBRARIES}
-            ${LANGUAGE_LIBS}
-)
+FIND_PACKAGE(IFEMDeps)
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${IFEM_BUILD_CXX_FLAGS}")
 
 # Required include directories
 SET(INCLUDES
-  ${GoTools_INCLUDE_DIRS}
-  ${GoTrivariate_INCLUDE_DIRS}
+  ${IFEM_DEPINCLUDES}
   ${PROJECT_SOURCE_DIR}/src/ASM
   ${PROJECT_SOURCE_DIR}/src/Eig
   ${PROJECT_SOURCE_DIR}/src/Integrands
@@ -84,89 +33,17 @@ SET(INCLUDES
   ${PROJECT_SOURCE_DIR}/3rdparty/expreval
 )
 
-FIND_PACKAGE(TinyXML)
-IF(TINYXML_INCLUDE_DIR AND TINYXML_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS}
-              ${TINYXML_LIBRARIES})
-   SET(INCLUDES ${INCLUDES}
-                ${TINYXML_INCLUDE_DIR})
-ELSE(TINYXML_INCLUDE_DIR AND TINYXML_LIBRARIES)
+IF(NOT IFEM_USE_SYSTEM_TINYXML)
   SET(INCLUDES ${INCLUDES}
                ${PROJECT_SOURCE_DIR}/3rdparty/tinyxml)
   FILE(GLOB_RECURSE TINYXML_SRCS ${PROJECT_SOURCE_DIR}/3rdparty/tinyxml/*.C)
-ENDIF(TINYXML_INCLUDE_DIR AND TINYXML_LIBRARIES)
-
-
-# Set libraries, include directories and compiler flags from optional packages
-
-IF(SuperLU_MT_LIBRARIES AND SuperLU_MT_INCLUDES AND "${ENABLE_SUPERLU_MT}")
-  FIND_PACKAGE(Threads REQUIRED)
-  SET(DEPLIBS ${DEPLIBS} ${SuperLU_MT_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
-  SET(INCLUDES ${INCLUDES} ${SuperLU_MT_INCLUDES})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SUPERLU_MT")
-ELSEIF(SuperLU_LIBRARIES AND SuperLU_INCLUDES)
-  SET(DEPLIBS ${DEPLIBS} ${SuperLU_LIBRARIES})
-  SET(INCLUDES ${INCLUDES} ${SuperLU_INCLUDES})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SUPERLU")
-ENDIF(SuperLU_MT_LIBRARIES AND SuperLU_MT_INCLUDES AND "${ENABLE_SUPERLU_MT}")
-
-IF(SPR_LIBRARIES)
-  SET(DEPLIBS ${DEPLIBS} ${SPR_LIBRARIES})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SPR -DUSE_F77SAM")
-ENDIF(SPR_LIBRARIES)
-
-IF(PETSC_LIBRARIES AND PETSC_INCLUDES)
-  SET(INCLUDES ${INCLUDES} ${PETSC_INCLUDES})
-  SET(DEPLIBS ${DEPLIBS} ${PETSC_LIBRARIES})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_PETSC")
-  IF(${ENABLE_PARALLEL_PETSC})
-    FIND_PACKAGE(MPI REQUIRED)
-    SET(INCLUDES ${INCLUDES} ${MPI_INCLUDE_PATH})
-    SET(DEPLIBS ${DEPLIBS} ${MPI_LIBRARIES})
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DPARALLEL_PETSC")
-  ENDIF(${ENABLE_PARALLEL_PETSC})
-  IF(ENABLE_SLEPC)
-    FIND_PACKAGE(SLEPc)
-    MESSAGE(STATUS ${SLEPC_LIBRARIES} ${SLEPC_INCLUDES})
-    IF(SLEPC_LIBRARIES AND SLEPC_INCLUDES)
-      SET(INCLUDES ${INCLUDES} ${SLEPC_INCLUDES})
-      SET(DEPLIBS ${DEPLIBS} ${SLEPC_LIBRARIES})
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SLEPC")
-    ENDIF(SLEPC_LIBRARIES AND SLEPC_INCLUDES)
-  ENDIF(ENABLE_SLEPC)
-ENDIF(PETSC_LIBRARIES AND PETSC_INCLUDES)
-
-IF(SAMG_LIBRARIES AND SAMG_INCLUDES)
-  SET(DEPLIBS ${DEPLIBS} ${SAMG_LIBRARIES})
-  SET(INCLUDES ${INCLUDES} ${SAMG_INCLUDES})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_SAMG -DSAMG_UNIX_LINUX=1 -DSAMG_LCASE_USCORE")
-ENDIF(SAMG_LIBRARIES AND SAMG_INCLUDES)
-
-IF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES)
-  SET(DEPLIBS ${DEPLIBS} ${VTFWRITER_LIBRARIES})
-  SET(INCLUDES ${INCLUDES} ${VTFWRITER_INCLUDES})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_VTFAPI=${VTFAPI}")
-ENDIF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES)
-
-IF(HDF5_LIBRARIES AND HDF5_INCLUDE_DIR)
-  SET(DEPLIBS ${DEPLIBS} ${HDF5_LIBRARIES})
-  SET(INCLUDES ${INCLUDES} ${HDF5_INCLUDE_DIR})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_HDF5=1")
-ENDIF(HDF5_LIBRARIES AND HDF5_INCLUDE_DIR)
+ENDIF(NOT IFEM_USE_SYSTEM_TINYXML)
 
 IF(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS)
-  SET(DEPLIBS ${DEPLIBS} ${LRSpline_LIBRARIES})
-  SET(INCLUDES
-    ${INCLUDES}
-    ${LRSpline_INCLUDE_DIRS}
-    ${PROJECT_SOURCE_DIR}/src/ASM/LR)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DHAS_LRSPLINE=1")
+  SET(INCLUDES ${INCLUDES}
+               ${PROJECT_SOURCE_DIR}/src/ASM/LR)
 ENDIF(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS)
 
-IF(OPENMP_FOUND)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -DUSE_OPENMP")
-ENDIF(OPENMP_FOUND)
-
 INCLUDE_DIRECTORIES(${INCLUDES})
 
 SET(EXECUTABLE_OUTPUT_PATH bin)
@@ -179,9 +56,6 @@ IF(NOT WIN32)
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-parentheses")
 ENDIF(NOT WIN32)
 
-# Additional compiler flags required by GoTools
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GoTools_CXX_FLAGS}")
-
 # Make the IFEM library
 FILE(GLOB_RECURSE IFEM_SRCS ${PROJECT_SOURCE_DIR}/src/*.[Cf]
                             ${PROJECT_SOURCE_DIR}/3rdparty/expreval/*.cpp)
@@ -193,18 +67,18 @@ ADD_LIBRARY(IFEM ${IFEM_SRCS} ${TINYXML_SRCS})
 # Make some Apps
 FILE(GLOB_RECURSE Poisson_SRCS ${PROJECT_SOURCE_DIR}/Apps/Poisson/*.C)
 ADD_EXECUTABLE(Poisson ${Poisson_SRCS})
-TARGET_LINK_LIBRARIES(Poisson IFEM ${DEPLIBS})
+TARGET_LINK_LIBRARIES(Poisson IFEM ${IFEM_DEPLIBS})
 
 FILE(GLOB_RECURSE LinEl_SRCS
   ${PROJECT_SOURCE_DIR}/Apps/LinearElasticity/main_LinEl3D.C
   ${PROJECT_SOURCE_DIR}/Apps/LinearElasticity/SIMLinEl*.C)
 ADD_EXECUTABLE(LinEl ${LinEl_SRCS})
-TARGET_LINK_LIBRARIES(LinEl IFEM ${DEPLIBS})
+TARGET_LINK_LIBRARIES(LinEl IFEM ${IFEM_DEPLIBS})
 
 IF(HDF5_LIBRARIES AND VTFWRITER_LIBRARIES)
   FILE(GLOB_RECURSE HDF2VTF_SRCS ${PROJECT_SOURCE_DIR}/Apps/HDF5toVTx/*.C)
   ADD_EXECUTABLE(HDF5toVTx ${HDF2VTF_SRCS})
-  TARGET_LINK_LIBRARIES(HDF5toVTx IFEM ${DEPLIBS})
+  TARGET_LINK_LIBRARIES(HDF5toVTx IFEM ${IFEM_DEPLIBS})
 ENDIF(HDF5_LIBRARIES AND VTFWRITER_LIBRARIES)
 
 ADD_CUSTOM_TARGET(doc doxygen 

HOWTO

@@ -26,22 +26,7 @@ Merk: Hvis du har en CMakeCache.txt i root når du prøver dette, vil
 det ikke fungere.
 
 Flagg av interesse:
-Per default lenker vi mot et minimum av bibliotek. Det betyr ingen
-PETSc og ingen SAMG. Disse kan slås på med opsjoner:
+Se cmake/Modules/IFEMOptions.cmake for en alltid-oppdatert liste
 
--DENABLE_PETSC:BOOL=1 og -DENABLE_SAMG:BOOL=1.
-
-For å kompilere mot parallel Petsc bruker du -DENABLE_PARALLEL_PETSC:BOOL=1
-
-Ved å spesifisere -DDISABLE_SUPERLU:BOOL=1 kan du slå av SuperLU ligningsløseren.
-Ved å spesifisere -DENABLE_SUPERLU_MT:BOOL=1 kan du aktivere multi-threaded SuperLU
-istedet for den serielle versjonen.
-
-Ved å spesifisere -DDISABLE_HDF5:BOOL=1 kan du slå av HDF5-støtten.
-
-Vi bygger kun libIFEM, Apps/Poisson og Apps/LinearElasticity.
-Stokes og FiniteDefElasticity har egne CMakeLists.txt. Disse
-er satt opp til å bruke in-tree kopi av libIFEM per default,
-men sjekker system hvis den ikke finner in-tree.
-Du kan tvinge system med -DFORCE_SYSTEM_IFEM:BOOL=1.
-Merk at in-tree sjekkes både for <root>/<type> og i <root>.
+VERBOSE_DEBUG=x  - verbose debugging
+VTFAPI=1/2 - tving bruk av VTF api v1 / v2

cmake/Modules/FindIFEM.cmake

@@ -1,13 +1,11 @@
-IF(IFEM_INCLUDES AND IFEM_LIBRARIES)
-  SET(IFEM_FIND_QUIETLY TRUE)
-ENDIF(IFEM_INCLUDES AND IFEM_LIBRARIES)
-
 IF(NOT DEFINED FORCE_SYSTEM_IFEM OR NOT "${FORCE_SYSTEM_IFEM}")
   FIND_PATH(IFEM_INCLUDES
     NAMES ASMbase.h
     PATHS ${PROJECT_SOURCE_DIR}/../../src/ASM)
 ENDIF(NOT DEFINED FORCE_SYSTEM_IFEM OR NOT "${FORCE_SYSTEM_IFEM}")
 
+FIND_PACKAGE(IFEMDeps)
+
 IF(IFEM_INCLUDES)
   # Build is in-tree
   MESSAGE(STATUS "Using in-tree libIFEM")
@@ -16,9 +14,11 @@ IF(IFEM_INCLUDES)
   FIND_PATH(SIM_INCL SIMbase.h ${PROJECT_SOURCE_DIR}/../../src/SIM)
   FIND_PATH(Alg_INCL MatVec.h  ${PROJECT_SOURCE_DIR}/../../src/LinAlg)
   FIND_PATH(Utl_INCL Vec3.h    ${PROJECT_SOURCE_DIR}/../../src/Utility)
-  FIND_PATH(Utl_3rd  tinyxml.h ${PROJECT_SOURCE_DIR}/../../3rdparty/tinyxml)
   SET(IFEM_INCLUDES ${IFEM_INCLUDES}
-    ${Int_INCL} ${SIM_INCL} ${Alg_INCL} ${Utl_INCL} ${Utl_3rd})
+                    ${Int_INCL}
+                    ${SIM_INCL}
+                    ${Alg_INCL}
+                    ${Utl_INCL})
 
   FIND_LIBRARY(IFEM_LIBRARIES
     NAMES IFEM
@@ -32,6 +32,10 @@ IF(IFEM_INCLUDES)
     SET(IFEM_LIBRARIES ${PROJECT_SOURCE_DIR}/../../${IFEM_BUILD_TYPE}/lib/libIFEM.a)
   ENDIF(NOT IFEM_LIBRARIES)
 
+  IF(NOT IFEM_USE_SYSTEM_TINYXML)
+    SET(IFEM_INCLUDES ${IFEM_INCLUDES}
+                      ${PROJECT_SOURCE_DIR}/../../3rdparty/tinyxml)
+  ENDIF(NOT IFEM_USE_SYSTEM_TINYXML)
 ELSE(IFEM_INCLUDES)
   IF(NOT DEFINED FORCE_SYSTEM_IFEM OR NOT "${FORCE_SYSTEM_IFEM}")
     MESSAGE(STATUS "No in-tree libIFEM found, looking for system library")
@@ -45,9 +49,12 @@ ELSE(IFEM_INCLUDES)
   FIND_LIBRARY(IFEM_LIBRARIES
     NAMES IFEM
     PATHS $ENV{HOME}/lib)
-
 ENDIF(IFEM_INCLUDES)
 
 INCLUDE(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(IFEM DEFAULT_MSG
-                                  IFEM_INCLUDES IFEM_LIBRARIES)
+                                  IFEM_LIBRARIES)
+
+SET(IFEM_LIBRARIES ${IFEM_LIBRARIES} ${IFEM_DEPLIBS})
+SET(IFEM_INCLUDES ${IFEM_INCLUDES} ${IFEM_DEPINCLUDES})
+

cmake/Modules/FindIFEMDeps.cmake

@@ -0,0 +1,145 @@
+INCLUDE(IFEMOptions)
+
+# IFEM includes Fortran code
+ENABLE_LANGUAGE(Fortran)
+IF(CMAKE_Fortran_COMPILER MATCHES ifort)
+  SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} -lifcore)
+ENDIF(CMAKE_Fortran_COMPILER MATCHES ifort)
+
+# And c++ code
+ENABLE_LANGUAGE(CXX)
+IF(CMAKE_CXX_COMPILER MATCHES icpc)
+  SET(IFEM_CXX_FLAGS "${IFEM_CXX_FLAGS} -DUSE_MKL -mkl=sequential")
+  SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DUSE_MKL -mkl=sequential")
+ELSE(CMAKE_CXX_COMPILER MATCHES icpc)
+  SET(IFEM_CXX_FLAGS "${IFEM_CXX_FLAGS} -DUSE_CBLAS")
+  SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DUSE_CBLAS")
+  FIND_PACKAGE(LAPACK REQUIRED)
+ENDIF(CMAKE_CXX_COMPILER MATCHES icpc)
+
+# Required dependences
+FIND_PACKAGE(GoTools REQUIRED)
+FIND_PACKAGE(GoTrivariate REQUIRED)
+FIND_PACKAGE(ARPACK REQUIRED)
+
+# Mimimum GoTools version
+IF(GoTools_VERSION_MAJOR LESS 3 OR NOT GoTools_VERSION_MAJOR)
+  MESSAGE(FATAL_ERROR "GoTools >= 3.0.0 required. bailing")
+ENDIF(GoTools_VERSION_MAJOR LESS 3 OR NOT GoTools_VERSION_MAJOR)
+
+SET(IFEM_DEPLIBS ${IFEM_DEPLIBS}
+                 ${GoTrivariate_LIBRARIES}
+                 ${GoTools_LIBRARIES}
+                 ${ARPACK_LIBRARIES}
+                 ${LAPACK_LIBRARIES})
+
+SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES}
+                     ${GoTools_INCLUDE_DIRS}
+                     ${GoTrivariate_INCLUDE_DIRS})
+
+SET(IFEM_CXX_FLAGS "${IFEM_CXX_FLAGS} ${GoTools_CXX_FLAGS}")
+SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} ${GoTools_CXX_FLAGS}")
+
+# HDF5
+IF(IFEM_USE_HDF5)
+  FIND_PACKAGE(HDF5)
+  IF(HDF5_LIBRARIES AND HDF5_INCLUDE_DIR)
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${HDF5_LIBRARIES})
+    SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${HDF5_INCLUDE_DIR})
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_HDF5=1")
+  ENDIF(HDF5_LIBRARIES AND HDF5_INCLUDE_DIR)
+ENDIF(IFEM_USE_HDF5)
+
+# TinyXML
+FIND_PACKAGE(TinyXML)
+IF(TINYXML_INCLUDE_DIR AND TINYXML_LIBRARIES)
+  SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${TINYXML_INCLUDE_DIR})
+  SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${TINYXML_LIBRARIES})
+  SET(IFEM_USE_SYSTEM_TINYXML 1)
+ENDIF(TINYXML_INCLUDE_DIR AND TINYXML_LIBRARIES)
+
+# SuperLU
+IF(IFEM_USE_SUPERLU)
+  FIND_PACKAGE(SuperLU)
+  IF(SuperLU_MT_LIBRARIES AND SuperLU_MT_INCLUDES AND IFEM_USE_SUPERLU_MT)
+    FIND_PACKAGE(Threads REQUIRED)
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${SuperLU_MT_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${SuperLU_MT_INCLUDES})
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_SUPERLU_MT")
+  ELSEIF(SuperLU_LIBRARIES AND SuperLU_INCLUDES AND IFEM_USE_SUPERLU_MT)
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${SuperLU_LIBRARIES})
+    SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${SuperLU_INCLUDES})
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_SUPERLU")
+  ENDIF(SuperLU_MT_LIBRARIES AND SuperLU_MT_INCLUDES AND IFEM_USE_SUPERLU_MT)
+ENDIF(IFEM_USE_SUPERLU)
+
+# LR splines
+IF(IFEM_USE_LRSPLINES)
+  FIND_PACKAGE(LRSpline)
+  IF(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS)
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${LRSpline_LIBRARIES})
+    SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${LRSpline_INCLUDE_DIRS})
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_LRSPLINE=1")
+  ENDIF(LRSpline_LIBRARIES AND LRSpline_INCLUDE_DIRS)
+ENDIF(IFEM_USE_LRSPLINES)
+
+# PETSc
+IF(IFEM_USE_PETSC)
+  FIND_PACKAGE(Petsc)
+  IF(PETSC_LIBRARIES AND PETSC_INCLUDES)
+    SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${PETSC_INCLUDES})
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${PETSC_LIBRARIES})
+    SET(IFEM_CXX_FLAGS "${IFEM_CXX_FLAGS} -DHAS_PETSC")
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_PETSC")
+    IF(IFEM_USE_PARALLEL_PETSC)
+      FIND_PACKAGE(MPI REQUIRED)
+      SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${MPI_INCLUDE_PATH})
+      SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${MPI_LIBRARIES})
+      SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DPARALLEL_PETSC")
+    ENDIF(IFEM_USE_PARALLEL_PETSC)
+    IF(IFEM_ENABLE_SLEPC)
+      FIND_PACKAGE(SLEPc)
+      MESSAGE(STATUS ${SLEPC_LIBRARIES} ${SLEPC_INCLUDES})
+      IF(SLEPC_LIBRARIES AND SLEPC_INCLUDES)
+        SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${SLEPC_INCLUDES})
+        SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${SLEPC_LIBRARIES})
+        SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_SLEPC")
+      ENDIF(SLEPC_LIBRARIES AND SLEPC_INCLUDES)
+    ENDIF(IFEM_ENABLE_SLEPC)
+  ENDIF(PETSC_LIBRARIES AND PETSC_INCLUDES)
+ENDIF(IFEM_USE_PETSC)
+
+# SPR
+IF(IFEM_USE_SPR)
+  IF(SPR_LIBRARIES)
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${SPR_LIBRARIES})
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_SPR -DUSE_F77SAM")
+  ENDIF(SPR_LIBRARIES)
+ENDIF(IFEM_USE_SPR)
+
+# SAMG
+IF(SAMG_LIBRARIES AND SAMG_INCLUDES)
+  SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${SAMG_LIBRARIES})
+  SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${SAMG_INCLUDES})
+  SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_SAMG -DSAMG_UNIX_LINUX=1 -DSAMG_LCASE_USCORE")
+ENDIF(SAMG_LIBRARIES AND SAMG_INCLUDES)
+
+# VTFWriter
+IF(IFEM_USE_VTFWRITER)
+  FIND_PACKAGE(VTFWriter)
+  IF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES)
+    SET(IFEM_DEPLIBS ${IFEM_DEPLIBS} ${VTFWRITER_LIBRARIES})
+    SET(IFEM_DEPINCLUDES ${IFEM_DEPINCLUDES} ${VTFWRITER_INCLUDES})
+    SET(IFEM_CXX_FLAGS "${IFEM_CXX_FLAGS} -DHAS_VTFAPI=${VTFAPI}")
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} -DHAS_VTFAPI=${VTFAPI}")
+  ENDIF(VTFWRITER_LIBRARIES AND VTFWRITER_INCLUDES)
+ENDIF(IFEM_USE_VTFWRITER)
+
+# OpenMP
+IF(IFEM_USE_OPENMP)
+  FIND_PACKAGE(OpenMP)
+  IF(OPENMP_FOUND)
+    SET(IFEM_CXX_FLAGS "${IFEM_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -DUSE_OPENMP")
+    SET(IFEM_BUILD_CXX_FLAGS "${IFEM_BUILD_CXX_FLAGS} ${OpenMP_CXX_FLAGS} -DUSE_OPENMP")
+  ENDIF(OPENMP_FOUND)
+ENDIF(IFEM_USE_OPENMP)

cmake/Modules/FindPetsc.cmake

@@ -12,16 +12,18 @@ FIND_PATH(
   )
 
 # Check for version
-EXECUTE_PROCESS(COMMAND cat "${PETSC_INCLUDE_DIR}/petscversion.h" OUTPUT_VARIABLE PETSC_HEADER)
-STRING(REGEX MATCH "PETSC_VERSION_RELEASE *([0-9]+)" PETSC_VERSION_RELEASE ${PETSC_HEADER})
-STRING(REGEX REPLACE "PETSC_VERSION_RELEASE *([0-9]+)" "\\1" PETSC_VERSION_RELEASE "${PETSC_VERSION_RELEASE}")
-STRING(REGEX MATCH "PETSC_VERSION_MAJOR *([0-9]+)" PETSC_VERSION_MAJOR ${PETSC_HEADER})
-STRING(REGEX REPLACE "PETSC_VERSION_MAJOR *([0-9]+)" "\\1" PETSC_VERSION_MAJOR "${PETSC_VERSION_MAJOR}")
-STRING(REGEX MATCH "PETSC_VERSION_MINOR *([0-9]+)" PETSC_VERSION_MINOR ${PETSC_HEADER})
-STRING(REGEX REPLACE "PETSC_VERSION_MINOR *([0-9]+)" "\\1" PETSC_VERSION_MINOR "${PETSC_VERSION_MINOR}")
+IF (PETSC_INCLUDE_DIR)
+  EXECUTE_PROCESS(COMMAND cat "${PETSC_INCLUDE_DIR}/petscversion.h" OUTPUT_VARIABLE PETSC_HEADER)
+  STRING(REGEX MATCH "PETSC_VERSION_RELEASE *([0-9]+)" PETSC_VERSION_RELEASE ${PETSC_HEADER})
+  STRING(REGEX REPLACE "PETSC_VERSION_RELEASE *([0-9]+)" "\\1" PETSC_VERSION_RELEASE "${PETSC_VERSION_RELEASE}")
+  STRING(REGEX MATCH "PETSC_VERSION_MAJOR *([0-9]+)" PETSC_VERSION_MAJOR ${PETSC_HEADER})
+  STRING(REGEX REPLACE "PETSC_VERSION_MAJOR *([0-9]+)" "\\1" PETSC_VERSION_MAJOR "${PETSC_VERSION_MAJOR}")
+  STRING(REGEX MATCH "PETSC_VERSION_MINOR *([0-9]+)" PETSC_VERSION_MINOR ${PETSC_HEADER})
+  STRING(REGEX REPLACE "PETSC_VERSION_MINOR *([0-9]+)" "\\1" PETSC_VERSION_MINOR "${PETSC_VERSION_MINOR}")
+ENDIF(PETSC_INCLUDE_DIR)
 
 # Add a better check when we need it (e.g. release is bumped)
-IF(PETSC_VERSION_MINOR LESS 2)
+IF(PETSC_VERSION_MINOR AND PETSC_VERSION_MINOR LESS 2)
   FIND_LIBRARY(PETSC_LIB_PETSC     petsc     PATHS /usr/lib $ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib)
   FIND_LIBRARY(PETSC_LIB_PETSCDM   petscdm   PATHS /usr/lib $ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib)
   FIND_LIBRARY(PETSC_LIB_PETSCVEC  petscvec  PATHS /usr/lib $ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib)
@@ -68,10 +70,12 @@ IF(PETSC_VERSION_MINOR LESS 2)
   SET(PETSCCONF_INCLUDE_DIR ${PETSCCONF_INCLUDE_DIR} ${PETSC_VARIABLES})
 
   SET(PETSC_INCLUDES ${PETSC_INCLUDE_DIR} ${PETSCCONF_INCLUDE_DIR})
-ELSE(PETSC_VERSION_MINOR LESS 2)
+  MARK_AS_ADVANCED(PETSC_LIBRARIES PETSC_INCLUDES)
+ENDIF(PETSC_VERSION_MINOR AND PETSC_VERSION_MINOR LESS 2)
+IF(PETSC_VERSION_MINOR AND PETSC_VERSION_MINOR GREATER 1)
   INCLUDE($ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/conf/PETScConfig.cmake)
   FIND_LIBRARY(PETSC_LIB_PETSC     petsc  HINTS $ENV{PETSC_DIR}/$ENV{PETSC_ARCH}/lib)
   SET(PETSC_LIBRARIES ${PETSC_LIB_PETSC} ${PETSC_PACKAGE_LIBS})
   SET(PETSC_INCLUDES ${PETSC_INCLUDE_DIR} ${PETSCCONF_INCLUDE_DIR} ${PETSC_PACKAGE_INCLUDES})
-ENDIF(PETSC_VERSION_MINOR LESS 2)
-MARK_AS_ADVANCED(PETSC_LIBRARIES PETSC_INCLUDES)
+  MARK_AS_ADVANCED(PETSC_LIBRARIES PETSC_INCLUDES)
+ENDIF(PETSC_VERSION_MINOR AND PETSC_VERSION_MINOR GREATER 1)

cmake/Modules/IFEMOptions.cmake

@@ -0,0 +1,11 @@
+OPTION(IFEM_USE_HDF5           "Compile with HDF5 support?"           ON)
+OPTION(IFEM_USE_SUPERLU        "Compile with SuperLU support?"        ON)
+OPTION(IFEM_USE_SUPERLU_MT     "Compile with SuperLU-MT support?"     ON)
+OPTION(IFEM_USE_LRSPLINES      "Compile with LR-splines support?"     ON)
+OPTION(IFEM_USE_PETSC          "Compile with PETSc support?"          ON)
+OPTION(IFEM_USE_PARALLEL_PETSC "Compile with parallel PETSc support?" OFF)
+OPTION(IFEM_USE_SLEPC          "Compile with SLEPc support?"          OFF)
+OPTION(IFEM_USE_SPR            "Compile with SPR support?"            OFF)
+OPTION(IFEM_USE_SAMG           "Compile with SAMG support?"           OFF)
+OPTION(IFEM_USE_VTFWRITER      "Compile with VTFWriter support?"      ON)
+OPTION(IFEM_USE_OPENMP         "Compile with OpenMP support?"         ON)