diff --git a/CMakeLists.txt b/CMakeLists.txt index 22c26d03..d2b6f5f6 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,6 +19,9 @@ ENDIF() # Set the project name PROJECT( LBPM-WIA ) +IF ( NOT CXX_STD ) + SET( CXX_STD 98 ) +ENDIF() # Set some common paths @@ -36,6 +39,7 @@ SET( CMAKE_MODULE_PATH ${LBPM_SOURCE_DIR} ${LBPM_SOURCE_DIR}/cmake ) SET( PROJ LBPM ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/macros.cmake" ) INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/libraries.cmake" ) +INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/LBPM-macros.cmake" ) # Check if we are only compiling docs @@ -56,8 +60,9 @@ INCLUDE( CTest ) ADD_CUSTOM_TARGET( doc ) ADD_CUSTOM_TARGET( latex_docs ) ADD_CUSTOM_TARGET( build-test ) +ADD_CUSTOM_TARGET( build-examples ) ADD_CUSTOM_TARGET( check COMMAND make test ) -ADD_DISTCLEAN( tests liblbpm-wia.* cpu gpu example common visit IO ) +ADD_DISTCLEAN( analysis null_timer tests liblbpm-wia.* cpu gpu example common visit IO ) # Check the compile mode and compile flags @@ -105,6 +110,8 @@ IF ( NOT ONLY_BUILD_DOCS ) CONFIGURE_LINE_COVERAGE() INCLUDE( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/SharedPtr.cmake" ) CONFIGURE_SHARED_PTR( "${LBPM_INSTALL_DIR}/include" "std" ) + # Set the external library link list + SET( EXTERNAL_LIBS ${EXTERNAL_LIBS} ${TIMER_LIBS} ) ENDIF() diff --git a/IO/MeshDatabase.cpp b/IO/MeshDatabase.cpp index 7b6113a7..33b43033 100644 --- a/IO/MeshDatabase.cpp +++ b/IO/MeshDatabase.cpp @@ -14,7 +14,6 @@ /**************************************************** -* Pack/unpack data from a buffer * ****************************************************/ // MeshType template<> @@ -243,7 +242,6 @@ std::vector gatherAll( const std::vector& meshes, MP { #ifdef USE_MPI PROFILE_START("gatherAll"); - int rank = MPI_WORLD_RANK(); int size = MPI_WORLD_SIZE(); // First pack the mesh data to local buffers size_t localsize = 0; diff --git a/IO/Writer.cpp b/IO/Writer.cpp index fc84fed7..52effdf6 100644 --- a/IO/Writer.cpp +++ b/IO/Writer.cpp @@ -160,7 +160,6 @@ void IO::writeData( int timestep, const std::vector& meshDat { PROFILE_START("writeData"); int rank = MPI_WORLD_RANK(); - int size = MPI_WORLD_SIZE(); // Create the output directory char path[100]; sprintf(path,"vis%03i",timestep); diff --git a/cmake/Find_TIMER.cmake b/cmake/Find_TIMER.cmake index a6628531..7ebc7aea 100644 --- a/cmake/Find_TIMER.cmake +++ b/cmake/Find_TIMER.cmake @@ -32,7 +32,7 @@ FUNCTION( CONFIGURE_TIMER DEFAULT_USE_TIMER NULL_TIMER_DIR ) VERIFY_PATH( ${TIMER_DIRECTORY}/lib ) FIND_LIBRARY( TIMER_LIBS NAMES timerutility PATHS ${TIMER_DIRECTORY}/lib NO_DEFAULT_PATH ) SET( TIMER_INCLUDE ${TIMER_DIRECTORY}/include ) - SET( TIMER_CXXFLAGS -DUSE_TIMER ) + SET( TIMER_CXXFLAGS "-DUSE_TIMER -I${TIMER_DIRECTORY}/include" ) SET( TIMER_LDFLAGS -L${TIMER_DIRECTORY}/lib ) SET( TIMER_LDLIBS -ltimerutility ) ELSE() @@ -40,7 +40,7 @@ FUNCTION( CONFIGURE_TIMER DEFAULT_USE_TIMER NULL_TIMER_DIR ) ENDIF() SET(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_RPATH} "${TIMER_DIRECTORY}/lib" PARENT_SCOPE ) INCLUDE_DIRECTORIES( "${TIMER_INCLUDE}" ) - ADD_DEFINITIONS( "-D USE_TIMER" ) + ADD_DEFINITIONS( -DUSE_TIMER ) MESSAGE( "Using timer utility" ) MESSAGE( " TIMER_LIBRARIES = ${TIMER_LIBS}" ) ELSE() diff --git a/cmake/LBPM-macros.cmake b/cmake/LBPM-macros.cmake new file mode 100644 index 00000000..d8a4dd7e --- /dev/null +++ b/cmake/LBPM-macros.cmake @@ -0,0 +1,42 @@ +# Copy an example folder +MACRO( INSTALL_EXAMPLE EXAMPLE ) + INSTALL( DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${EXAMPLE}" DESTINATION "${LBPM_INSTALL_DIR}/example" ) +ENDMACRO() + + +# Create an example test +CONFIGURE_FILE( "${${PROJ}_SOURCE_DIR}/cmake/CompareOutput.cmake" "${${PROJ}_BUILD_DIR}/CompareOutput.cmake" COPYONLY ) +MACRO( TEST_EXAMPLE EXAMPLE EXEFILE PROCS ${ARGN} ) + SET( EXAMPLE_DIR "${CMAKE_CURRENT_BINARY_DIR}/${EXAMPLE}" ) + # Copy the example directory + ADD_CUSTOM_TARGET( + ${EXAMPLE} ALL + ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_SOURCE_DIR}/${EXAMPLE}" "${EXAMPLE_DIR}" + DEPENDS ${EXEFILE} + ) + # Create a wrapper script to run the test and copy the output to ${EXAMPLE}.out + SET( FILENAME "${EXAMPLE_DIR}/run-${EXAMPLE}" ) + FILE(WRITE "${FILENAME}" "# This is a automatically generated file to run example--${EXAMPLE}\n" ) + FILE(APPEND "${FILENAME}" "${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} \"${LBPM_INSTALL_DIR}/bin/${EXEFILE}\" ${ARGN} 2>&1 | tee ${EXAMPLE}.out\n\n" ) + # Create the test to run the example + SET( TESTNAME example--${EXAMPLE} ) + EXECUTE_PROCESS(COMMAND chmod 755 "${FILENAME}") + ADD_TEST( + NAME ${TESTNAME} + WORKING_DIRECTORY "${EXAMPLE_DIR}" + COMMAND "${FILENAME}" + ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) + # Create a test that checks the output against the data in EXAMPLE/OutputAns.txt + IF ( EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${EXAMPLE}/ExampleOutput.txt" ) + ADD_TEST( + NAME ${TESTNAME}-output + WORKING_DIRECTORY "${EXAMPLE_DIR}" + COMMAND ${CMAKE_COMMAND} -DTEST=${EXAMPLE}.out -DGOLD=ExampleOutput.txt -P "${${PROJ}_BUILD_DIR}/CompareOutput.cmake" + ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES DEPENDS ${TESTNAME} ) + ENDIF() +ENDMACRO() + diff --git a/cmake/libraries.cmake b/cmake/libraries.cmake index ede9d712..b843c2e6 100644 --- a/cmake/libraries.cmake +++ b/cmake/libraries.cmake @@ -86,15 +86,28 @@ MACRO( CONFIGURE_MPI ) IF ( USE_MPI ) # Check if we specified the MPI directory IF ( MPI_DIRECTORY ) - # Check the provided MPI directory for include files and the mpi executable - VERIFY_PATH ( ${MPI_DIRECTORY} ) - SET ( MPI_INCLUDE_PATH ${MPI_DIRECTORY}/include ) - VERIFY_PATH ( ${MPI_INCLUDE_PATH} ) - IF ( NOT EXISTS ${MPI_INCLUDE_PATH}/mpi.h ) - MESSAGE( FATAL_ERROR "mpi.h not found in ${MPI_INCLUDE_PATH}" ) + # Check the provided MPI directory for include files + VERIFY_PATH( "${MPI_DIRECTORY}" ) + IF ( EXISTS "${MPI_DIRECTORY}/include/mpi.h" ) + SET( MPI_INCLUDE_PATH "${MPI_DIRECTORY}/include" ) + ELSEIF ( EXISTS "${MPI_DIRECTORY}/Inc/mpi.h" ) + SET( MPI_INCLUDE_PATH "${MPI_DIRECTORY}/Inc" ) + ELSE() + MESSAGE( FATAL_ERROR "mpi.h not found in ${MPI_DIRECTORY}/include" ) ENDIF () INCLUDE_DIRECTORIES ( ${MPI_INCLUDE_PATH} ) SET ( MPI_INCLUDE ${MPI_INCLUDE_PATH} ) + # Set MPI libraries + IF ( ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" ) + FIND_LIBRARY( MSMPI_LIB NAMES msmpi PATHS "${MPI_DIRECTORY}/Lib/x64" NO_DEFAULT_PATH ) + FIND_LIBRARY( MSMPI_LIB NAMES msmpi PATHS "${MPI_DIRECTORY}/Lib/amd64" NO_DEFAULT_PATH ) + FIND_LIBRARY( MSMPIFEC_LIB NAMES msmpifec PATHS "${MPI_DIRECTORY}/Lib/x64" NO_DEFAULT_PATH ) + FIND_LIBRARY( MSMPIFEC_LIB NAMES msmpifec PATHS "${MPI_DIRECTORY}/Lib/amd64" NO_DEFAULT_PATH ) + FIND_LIBRARY( MSMPIFMC_LIB NAMES msmpifmc PATHS "${MPI_DIRECTORY}/Lib/x64" NO_DEFAULT_PATH ) + FIND_LIBRARY( MSMPIFMC_LIB NAMES msmpifmc PATHS "${MPI_DIRECTORY}/Lib/amd64" NO_DEFAULT_PATH ) + SET( MPI_LIBRARIES ${MSMPI_LIB} ${MSMPIFEC_LIB} ${MSMPIFMC_LIB} ) + ENDIF() + # Set the mpi executable IF ( MPIEXEC ) # User specified the MPI command directly, use as is ELSEIF ( MPIEXEC_CMD ) @@ -116,14 +129,20 @@ MACRO( CONFIGURE_MPI ) ENDIF() ELSEIF ( MPI_COMPILER ) # The mpi compiler should take care of everything + IF ( MPI_INCLUDE ) + INCLUDE_DIRECTORIES( ${MPI_INCLUDE} ) + ENDIF() ELSE() # Perform the default search for MPI INCLUDE ( FindMPI ) IF ( NOT MPI_FOUND ) + MESSAGE( " MPI_INCLUDE = ${MPI_INCLUDE}" ) + MESSAGE( " MPI_LINK_FLAGS = ${MPI_LINK_FLAGS}" ) + MESSAGE( " MPI_LIBRARIES = ${MPI_LIBRARIES}" ) MESSAGE( FATAL_ERROR "Did not find MPI" ) ENDIF () - INCLUDE_DIRECTORIES ( ${MPI_INCLUDE_PATH} ) - SET ( MPI_INCLUDE ${MPI_INCLUDE_PATH} ) + INCLUDE_DIRECTORIES( "${MPI_INCLUDE_PATH}" ) + SET( MPI_INCLUDE "${MPI_INCLUDE_PATH}" ) ENDIF() # Check if we need to use MPI for serial tests CHECK_ENABLE_FLAG( USE_MPI_FOR_SERIAL_TESTS 0 ) @@ -132,12 +151,10 @@ MACRO( CONFIGURE_MPI ) SET( MPIEXEC mpirun ) ENDIF() IF ( NOT MPIEXEC_NUMPROC_FLAG ) - SET(MPIEXEC_NUMPROC_FLAG "-n") + SET( MPIEXEC_NUMPROC_FLAG "-np" ) ENDIF() - # Check if we need to use MPI for serial tests - SET( MPI_CXXFLAGS -DUSE_MPI -I${MPI_INCLUDE} ) # Set the definitions - ADD_DEFINITIONS( "-D USE_MPI" ) + ADD_DEFINITIONS( "-DUSE_MPI" ) MESSAGE( "Using MPI" ) MESSAGE( " MPIEXEC = ${MPIEXEC}" ) MESSAGE( " MPIEXEC_NUMPROC_FLAG = ${MPIEXEC_NUMPROC_FLAG}" ) @@ -170,12 +187,8 @@ MACRO( CONFIGURE_SYSTEM ) ENDIF() # Remove extra library links # Get the compiler - SET_COMPILER () + IDENTIFY_COMPILER() CHECK_ENABLE_FLAG( USE_STATIC 0 ) - IF ( USE_STATIC ) - SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-static") # Add static flag - SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "-static") # Add static flag - ENDIF() # Add system dependent flags MESSAGE("System is: ${CMAKE_SYSTEM_NAME}") IF ( ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" ) @@ -201,7 +214,12 @@ MACRO( CONFIGURE_SYSTEM ) # Linux specific system libraries SET( SYSTEM_LIBS -lz -lpthread -ldl ) IF ( NOT USE_STATIC ) - SET( SYSTEM_LDFLAGS ${SYSTEM_LDFLAGS} -rdynamic ) # Needed for backtrace to print function names + # Try to add rdynamic so we have names in backtrace + SET( CMAKE_REQUIRED_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS} -rdynamic" ) + CHECK_CXX_SOURCE_COMPILES( "int main() { return 0;}" rdynamic ) + IF ( rdynamic ) + SET( SYSTEM_LDFLAGS ${SYSTEM_LDFLAGS} -rdynamic ) + ENDIF() ENDIF() IF ( USING_GCC ) SET( SYSTEM_LIBS ${SYSTEM_LIBS} -lgfortran ) @@ -217,7 +235,13 @@ MACRO( CONFIGURE_SYSTEM ) MESSAGE( FATAL_ERROR "OS not detected" ) ENDIF() # Set the compile flags based on the build - SET_COMPILE_FLAGS() + SET_COMPILER_FLAGS() + # Add the static flag if necessary + IF ( USE_STATIC ) + SET_STATIC_FLAGS() + ENDIF() + # Print some flags + MESSAGE( "LDLIBS = ${LDLIBS}" ) ENDMACRO () diff --git a/cmake/macros.cmake b/cmake/macros.cmake index 94bb1350..39f1ee5d 100644 --- a/cmake/macros.cmake +++ b/cmake/macros.cmake @@ -1,5 +1,10 @@ +INCLUDE(CheckCCompilerFlag) INCLUDE(CheckCSourceCompiles) -SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)" ) +INCLUDE(CheckCXXCompilerFlag) +INCLUDE(CheckCXXSourceCompiles) +IF ( NOT TEST_FAIL_REGULAR_EXPRESSION ) + SET( TEST_FAIL_REGULAR_EXPRESSION "(FAILED)|(leaked context IDs detected)|(handles are still allocated)" ) +ENDIF() # Check that the PROJ and ${PROJ}_INSTALL_DIR variables are set @@ -10,9 +15,21 @@ ENDIF() IF ( NOT ${PROJ}_INSTALL_DIR ) MESSAGE(FATAL_ERROR "${PROJ}_INSTALL_DIR must be set before including macros.cmake") ENDIF() -IF ( NOT ${PROJ}_BUILD_DIR ) - MESSAGE(FATAL_ERROR "${PROJ}_BUILD_DIR must be set before including macros.cmake") + + +# Add some default targets if they do not exist +IF ( NOT TARGET copy-${PROJ}-Data ) + ADD_CUSTOM_TARGET( copy-${PROJ}-Data ALL ) ENDIF() +IF ( NOT TARGET copy-${PROJ}-include ) + ADD_CUSTOM_TARGET ( copy-${PROJ}-include ALL ) +ENDIF() + + +# Macro to set a global variable +MACRO(GLOBAL_SET VARNAME) + SET(${VARNAME} ${ARGN} CACHE INTERNAL "") +ENDMACRO() # Macro to print all variables @@ -24,16 +41,61 @@ MACRO( PRINT_ALL_VARIABLES ) ENDMACRO() +# CMake assert +MACRO(ASSERT test comment) + IF (NOT ${test}) + MESSSAGE(FATAL_ERROR "Assertion failed: ${comment}") + ENDIF(NOT ${test}) +ENDMACRO(ASSERT) + + +# Macro to convert a m4 file +# This command converts a file of the format "global_path/file.m4" +# and convertes it to file.F. It also requires the path. +MACRO( CONVERT_M4_FORTRAN IN LOCAL_PATH OUT_PATH ) + STRING(REGEX REPLACE ${LOCAL_PATH} "" OUT ${IN} ) + STRING(REGEX REPLACE "/" "" OUT ${OUT} ) + STRING(REGEX REPLACE "(.fm4)|(.m4)" ".F" OUT "${CMAKE_CURRENT_BINARY_DIR}/${OUT_PATH}/${OUT}" ) + IF ( NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${OUT_PATH}" ) + FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${OUT_PATH}" ) + ENDIF() + CONFIGURE_FILE ( ${IN} ${IN} COPYONLY ) + IF ("${CMAKE_GENERATOR}" STREQUAL "Xcode") + STRING(REGEX REPLACE ".F" ".o" OUT2 "${OUT}" ) + STRING(REGEX REPLACE ";" " " COMPILE_CMD "${CMAKE_Fortran_COMPILER} -c ${OUT} ${CMAKE_Fortran_FLAGS} -o ${OUT2}") + STRING(REGEX REPLACE "\\\\" "" COMPILE_CMD "${COMPILE_CMD}") + MESSAGE("COMPILE_CMD = ${COMPILE_CMD}") + SET( COMPILE_CMD ${COMPILE_CMD} ) + add_custom_command( + OUTPUT ${OUT2} + COMMAND m4 -I${LOCAL_PATH} -I${SAMRAI_FORTDIR} ${M4DIRS} ${IN} > ${OUT} + COMMAND ${COMPILE_CMD} + DEPENDS ${IN} + ) + set_source_files_properties(${OUT2} PROPERTIES GENERATED true) + SET( SOURCES ${SOURCES} "${OUT2}" ) + ELSE() + add_custom_command( + OUTPUT ${OUT} + COMMAND m4 -I${LOCAL_PATH} -I${SAMRAI_FORTDIR} ${M4DIRS} ${M4_OPTIONS} ${IN} > ${OUT} + DEPENDS ${IN} + ) + set_source_files_properties(${OUT} PROPERTIES GENERATED true) + SET( SOURCES ${SOURCES} "${OUT}" ) + ENDIF() +ENDMACRO() + + # Add a package to the project's library MACRO( ADD_${PROJ}_LIBRARY PACKAGE ) - #INCLUDE_DIRECTORIES ( ${${PROJ}_INSTALL_DIR}/include/${PACKAGE} ) ADD_SUBDIRECTORY( ${PACKAGE} ) ENDMACRO() # Add a project executable -MACRO( ADD_${PROJ}_EXECUTABLE PACKAGE ) - ADD_SUBDIRECTORY( ${PACKAGE} ) +MACRO( ADD_${PROJ}_EXECUTABLE EXEFILE ) + ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) + INSTALL( TARGETS ${EXEFILE} DESTINATION ${${PROJ}_INSTALL_DIR}/bin ) ENDMACRO() @@ -44,7 +106,7 @@ MACRO (BEGIN_PACKAGE_CONFIG PACKAGE) SET( CSOURCES "" ) SET( FSOURCES "" ) SET( M4FSOURCES "" ) - SET( CUSOURCES "" ) + SET( CUDASOURCES "" ) SET( SOURCES "" ) SET( CURPACKAGE ${PACKAGE} ) ENDMACRO () @@ -54,87 +116,120 @@ ENDMACRO () MACRO (FIND_FILES) # Find the C/C++ headers SET( T_HEADERS "" ) - FILE( GLOB T_HEADERS "*.h" "*.hh" "*.hpp" "*.I" ) + FILE( GLOB T_HEADERS "*.h" "*.H" "*.hh" "*.hpp" "*.I" ) + # Find the CUDA sources + SET( T_CUDASOURCES "" ) + FILE( GLOB T_CUDASOURCES "*.cu" ) # Find the C sources SET( T_CSOURCES "" ) FILE( GLOB T_CSOURCES "*.c" ) # Find the C++ sources SET( T_CXXSOURCES "" ) FILE( GLOB T_CXXSOURCES "*.cc" "*.cpp" "*.cxx" "*.C" ) - # Find the C++ sources - SET( T_CUSOURCES "" ) - FILE( GLOB T_CUSOURCES "*.cu" ) + # Find the Fortran sources + SET( T_FSOURCES "" ) + FILE( GLOB T_FSOURCES "*.f" "*.f90" "*.F" "*.F90" ) + # Find the m4 fortran source (and convert) + SET( T_M4FSOURCES "" ) + FILE( GLOB T_M4FSOURCES "*.m4" "*.fm4" ) + FOREACH( m4file ${T_M4FSOURCES} ) + CONVERT_M4_FORTRAN( ${m4file} ${CMAKE_CURRENT_SOURCE_DIR} "" ) + ENDFOREACH() # Add all found files to the current lists SET( HEADERS ${HEADERS} ${T_HEADERS} ) SET( CXXSOURCES ${CXXSOURCES} ${T_CXXSOURCES} ) + SET( CUDASOURCES ${CUDASOURCES} ${T_CUDASOURCES} ) SET( CSOURCES ${CSOURCES} ${T_CSOURCES} ) - SET( CUSOURCES ${CUSOURCES} ${T_CUSOURCES} ) - SET( SOURCES ${SOURCES} ${T_CXXSOURCES} ${T_CSOURCES} ) + SET( FSOURCES ${FSOURCES} ${T_FSOURCES} ) + SET( M4FSOURCES ${M4FSOURCES} ${T_M4FSOURCES} ) + SET( SOURCES ${SOURCES} ${T_CXXSOURCES} ${T_CSOURCES} ${T_FSOURCES} ${T_M4FSOURCES} ) ENDMACRO() # Find the source files -MACRO (FIND_FILES_PATH IN_PATH) +MACRO( FIND_FILES_PATH IN_PATH ) # Find the C/C++ headers SET( T_HEADERS "" ) - FILE( GLOB T_HEADERS "${IN_PATH}/*.h" "${IN_PATH}/*.hh" "${IN_PATH}/*.hpp" "${IN_PATH}/*.I" ) + FILE( GLOB T_HEADERS "${IN_PATH}/*.h" "${IN_PATH}/*.H" "${IN_PATH}/*.hh" "${IN_PATH}/*.hpp" "${IN_PATH}/*.I" ) + # Find the CUDA sources + SET( T_CUDASOURCES "" ) + FILE( GLOB T_CUDASOURCES "${IN_PATH}/*.cu" ) # Find the C sources SET( T_CSOURCES "" ) FILE( GLOB T_CSOURCES "${IN_PATH}/*.c" ) # Find the C++ sources SET( T_CXXSOURCES "" ) FILE( GLOB T_CXXSOURCES "${IN_PATH}/*.cc" "${IN_PATH}/*.cpp" "${IN_PATH}/*.cxx" "${IN_PATH}/*.C" ) - # Find the CUDA sources - SET( T_CUSOURCES "" ) - FILE( GLOB T_CUSOURCES "${IN_PATH}/*.cu" ) + # Find the Fortran sources + SET( T_FSOURCES "" ) + FILE( GLOB T_FSOURCES "${IN_PATH}/*.f" "${IN_PATH}/*.f90" "${IN_PATH}/*.F" "${IN_PATH}/*.F90" ) + # Find the m4 fortran source (and convert) + SET( T_M4FSOURCES "" ) + FILE( GLOB T_M4FSOURCES "${IN_PATH}/*.m4" "${IN_PATH}/*.fm4" ) + FOREACH( m4file ${T_M4FSOURCES} ) + CONVERT_M4_FORTRAN( ${m4file} ${CMAKE_CURRENT_SOURCE_DIR}/${IN_PATH} ${IN_PATH} ) + ENDFOREACH () # Add all found files to the current lists SET( HEADERS ${HEADERS} ${T_HEADERS} ) SET( CXXSOURCES ${CXXSOURCES} ${T_CXXSOURCES} ) + SET( CUDASOURCES ${CUDASOURCES} ${T_CUDASOURCES} ) SET( CSOURCES ${CSOURCES} ${T_CSOURCES} ) - SET( CUSOURCES ${CUSOURCES} ${T_CUSOURCES} ) - SET( SOURCES ${SOURCES} ${T_CXXSOURCES} ${T_CSOURCES} ${T_CUSOURCES} ) + SET( FSOURCES ${FSOURCES} ${T_FSOURCES} ) + SET( SOURCES ${SOURCES} ${T_CXXSOURCES} ${T_CSOURCES} ${T_FSOURCES} ) ENDMACRO() # Add a subdirectory MACRO( ADD_PACKAGE_SUBDIRECTORY SUBDIR ) - SET( FULLSUBDIR ${CMAKE_CURRENT_SOURCE_DIR}/${SUBDIR} ) FIND_FILES_PATH( ${SUBDIR} ) - FILE( GLOB HFILES RELATIVE ${FULLSUBDIR} ${SUBDIR}/*.h ${SUBDIR}/*.hh ${SUBDIR}/*.hpp ${SUBDIR}/*.I ) - FOREACH( HFILE ${HFILES} ) - CONFIGURE_FILE( ${FULLSUBDIR}/${HFILE} ${${PROJ}_INSTALL_DIR}/include/${SUBDIR}/${HFILE} COPYONLY ) - INCLUDE_DIRECTORIES( ${FULLSUBDIR} ) - ENDFOREACH() - ADD_SUBDIRECTORY( ${SUBDIR} ) +ENDMACRO() + + +# Add an external directory +# Note: this will add the files to compile but will not copy the headers +MACRO( ADD_EXTERNAL_DIRECTORY SUBDIR ) + FIND_FILES_PATH( ${SUBDIR} ) ENDMACRO() # Install a package -MACRO( INSTALL_LBPM_TARGET PACKAGE ) +MACRO( INSTALL_${PROJ}_TARGET PACKAGE ) # Find all files in the current directory FIND_FILES() + # Create the copy target + SET( COPY_TARGET copy-${PROJ}-include ) + IF( NOT TARGET ${COPY_TARGET} ) + ADD_CUSTOM_TARGET( ${COPY_TARGET} ALL ) + ADD_DEPENDENCIES( copy-${PROJ}-include ${COPY_TARGET} ) + ENDIF() # Copy the header files to the include path - FILE( GLOB HFILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.hh ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/*.I ) + FILE( GLOB HFILES RELATIVE "${${PROJ}_SOURCE_DIR}" ${HEADERS} ) FOREACH( HFILE ${HFILES} ) - #CONFIGURE_FILE( ${CMAKE_CURRENT_SOURCE_DIR}/${HFILE} ${${PROJ}_INSTALL_DIR}/include/${CURPACKAGE}/${HFILE} COPYONLY ) - CONFIGURE_FILE( ${CMAKE_CURRENT_SOURCE_DIR}/${HFILE} ${${PROJ}_INSTALL_DIR}/include/${HFILE} COPYONLY ) + SET( SRC_FILE "${${PROJ}_SOURCE_DIR}/${HFILE}" ) + SET( DST_FILE "${${PROJ}_INSTALL_DIR}/include/${HFILE}" ) + # Only copy the headers if the exisit in the project source directory + IF ( EXISTS "${SRC_FILE}" ) + ADD_CUSTOM_COMMAND(TARGET ${COPY_TARGET} + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${DST_FILE}" + DEPENDS "${SRC_FILE}" + ) + ENDIF() ENDFOREACH() - # Configure the CUDA files - IF ( CUSOURCES ) - CUDA_COMPILE( CUOBJS ${CUSOURCES} ) + # Add the library and install the package + IF ( NOT ONLY_BUILD_DOCS AND ( SOURCES OR CUDASOURCES ) ) + IF( USE_CUDA ) + CUDA_COMPILE( CUBINS ${CUDASOURCES} ) + ENDIF() + ADD_LIBRARY( ${PACKAGE} ${LIB_TYPE} ${SOURCES} ${CUBINS} ) + IF ( TARGET write_repo_version ) + ADD_DEPENDENCIES( ${PACKAGE} write_repo_version ) + ENDIF() + ADD_DEPENDENCIES ( ${PACKAGE} copy-${PROJ}-include ) + INSTALL( TARGETS ${PACKAGE} DESTINATION ${${PROJ}_INSTALL_DIR}/lib ) + ELSE() + ADD_CUSTOM_TARGET( ${PACKAGE} ALL ) ENDIF() - # Add the library - ADD_LIBRARY( ${PACKAGE} ${LIB_TYPE} ${SOURCES} ${CUOBJS} ) - SET( TEST_DEP_LIST ${PACKAGE} ${TEST_DEP_LIST} ) - TARGET_LINK_LIBRARIES( ${PACKAGE} ${COVERAGE_LIBS} ${SYSTEM_LIBS} ${LDLIBS} ) - TARGET_LINK_LIBRARIES( ${PACKAGE} ${LAPACK_LIBS} ${BLAS_LIBS} ) - IF ( USE_MPI ) - TARGET_LINK_LIBRARIES( ${PACKAGE} ${MPI_LIBRARIES} ) - ENDIF() - TARGET_LINK_LIBRARIES( ${PACKAGE} ${COVERAGE_LIBS} ${SYSTEM_LIBS} ${LDLIBS} ) - # Install the package - INSTALL( TARGETS ${PACKAGE} DESTINATION ${${PROJ}_INSTALL_DIR}/lib ) - INSTALL( FILES ${HFILES} DESTINATION ${${PROJ}_INSTALL_DIR}/include ) # Clear the sources SET( HEADERS "" ) SET( CSOURCES "" ) @@ -161,126 +256,334 @@ MACRO( VERIFY_PATH PATH_NAME ) ENDMACRO() +# Macro to tell cmake to use static libraries +MACRO( SET_STATIC_FLAGS ) + # Remove extra library links + set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic + set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS) + set(CMAKE_SHARED_LIBRARY_C_FLAGS) # remove -fPIC + set(CMAKE_SHARED_LIBRARY_CXX_FLAGS) + set(CMAKE_SHARED_LINKER_FLAGS) + set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS) # remove -rdynamic + set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS) + # Add the static flag if necessary + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static") # Add static flag + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static ") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static ") + SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-static") # Add static flag + SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "-static") # Add static flag +ENDMACRO() + + # Macro to identify the compiler -MACRO( SET_COMPILER ) +MACRO( IDENTIFY_COMPILER ) # SET the C/C++ compiler IF ( CMAKE_C_COMPILER_WORKS OR CMAKE_C_COMPILER_WORKS ) IF( CMAKE_COMPILE_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) SET( USING_GCC TRUE ) - ADD_DEFINITIONS( -D USING_GCC ) + ADD_DEFINITIONS( "-D USING_GCC" ) MESSAGE("Using gcc") ELSEIF( MSVC OR MSVC_IDE OR MSVC60 OR MSVC70 OR MSVC71 OR MSVC80 OR CMAKE_COMPILER_2005 OR MSVC90 OR MSVC10 ) IF( NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows" ) MESSAGE( FATAL_ERROR "Using microsoft compilers on non-windows system?" ) ENDIF() - SET( USING_MICROSOFT TRUE ) - ADD_DEFINITIONS( -D USING_MICROSOFT ) + SET( USING_MSVC TRUE ) + ADD_DEFINITIONS( "-D USING_MSVC" ) MESSAGE("Using Microsoft") ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "Intel") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Intel") ) SET(USING_ICC TRUE) - ADD_DEFINITIONS( -D USING_ICC ) + ADD_DEFINITIONS( "-D USING_ICC" ) MESSAGE("Using icc") - ELSEIF( ${CMAKE_C_COMPILER_ID} MATCHES "PGI") + ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "PGI") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "PGI") ) SET(USING_PGCC TRUE) - ADD_DEFINITIONS( -D USING_ICCPGCC ) + ADD_DEFINITIONS( "-D USING_PGCC" ) MESSAGE("Using pgCC") - ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "CRAY") OR (${CMAKE_C_COMPILER_ID} MATCHES "Cray") ) + ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "CRAY") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "CRAY") OR + (${CMAKE_C_COMPILER_ID} MATCHES "Cray") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Cray") ) SET(USING_CRAY TRUE) - ADD_DEFINITIONS( -D USING_CRAY ) + ADD_DEFINITIONS( "-D USING_CRAY" ) MESSAGE("Using Cray") - ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "CLANG") OR (${CMAKE_C_COMPILER_ID} MATCHES "Clang") ) + ELSEIF( (${CMAKE_C_COMPILER_ID} MATCHES "CLANG") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "CLANG") OR + (${CMAKE_C_COMPILER_ID} MATCHES "Clang") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") ) SET(USING_CLANG TRUE) - ADD_DEFINITIONS( -D USING_CLANG ) + ADD_DEFINITIONS( "-D USING_CLANG" ) MESSAGE("Using Clang") ELSE() SET(USING_DEFAULT TRUE) MESSAGE("${CMAKE_C_COMPILER_ID}") - MESSAGE("Unknown C/C++ compiler, default flags will be used") + MESSAGE(WARNING "Unknown C/C++ compiler, default flags will be used") + ENDIF() + ENDIF() + # SET the Fortran++ compiler + IF ( CMAKE_Fortran_COMPILER_WORKS ) + IF( CMAKE_COMPILE_IS_GFORTRAN OR (${CMAKE_Fortran_COMPILER_ID} MATCHES "GNU") ) + SET( USING_GFORTRAN TRUE ) + MESSAGE("Using gfortran") + ELSEIF ( (${CMAKE_Fortran_COMPILER_ID} MATCHES "Intel") ) + SET(USING_IFORT TRUE) + MESSAGE("Using ifort") + ELSEIF ( ${CMAKE_Fortran_COMPILER_ID} MATCHES "PGI") + SET(USING_PGF90 TRUE) + MESSAGE("Using pgf90") + ELSE() + SET(USING_DEFAULT TRUE) + MESSAGE("${CMAKE_Fortran_COMPILER_ID}") + MESSAGE("Unknown Fortran compiler, default flags will be used") ENDIF() ENDIF() ENDMACRO() -# Macro to set the compiler specific flags -MACRO ( SET_COMPILER_FLAGS ) +# Macro to set the proper warnings +MACRO( SET_WARNINGS ) IF ( USING_GCC ) # Add gcc specific compiler options - # -Wno-reorder: warning: "" will be initialized after "" when initialized here - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98") - SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-char-subscripts -Wno-comment -Wno-unused-variable -Wno-unused-but-set-variable") - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-char-subscripts -Wno-comment -Wno-unused-variable -Wno-unused-but-set-variable") - ELSEIF ( USING_MICROSOFT ) + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wcast-align -Wlogical-op -Wno-char-subscripts -Wno-unused-parameter -Wno-unused-variable") + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wcast-align -Wlogical-op -Wno-char-subscripts -Wno-unused-parameter -Wno-unused-variable") + ELSEIF ( USING_MSVC ) # Add Microsoft specifc compiler options SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D _SCL_SECURE_NO_WARNINGS /D _CRT_SECURE_NO_WARNINGS /D _ITERATOR_DEBUG_LEVEL=0" ) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D _SCL_SECURE_NO_WARNINGS /D _CRT_SECURE_NO_WARNINGS /D _ITERATOR_DEBUG_LEVEL=0" ) ELSEIF ( USING_ICC ) - ## Add Intel specifc compiler options - #SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall" ) - #SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall" ) - ## Disable warnings that I think are irrelavent (may need to be revisited) - #SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -wd383 -wd981" ) - #SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -wd383 -wd981" ) + # Add Intel specifc compiler options + SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall" ) + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall" ) ELSEIF ( USING_CRAY ) # Add default compiler options SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS}") SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS}") ELSEIF ( USING_PGCC ) # Add default compiler options - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS}") - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS}") + SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -lpthread") + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -lpthread -Minform=inform -Mlist --display_error_number") + # Suppress unreachable code warning, it causes non-useful warnings with some tests/templates + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} --diag_suppress 111,128,185") ELSEIF ( USING_CLANG ) + # Add default compiler options + SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall") + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall") + ELSEIF ( USING_DEFAULT ) # Add default compiler options SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS}") SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS}") - ELSEIF ( USING_DEFAULT ) - ## Add default compiler options - #SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -Wall") - #SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -Wall") - ENDIF () -ENDMACRO () + ENDIF() +ENDMACRO() # Macro to add user compile flags MACRO( ADD_USER_FLAGS ) - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} ${CFLAGS} ${LDFLAGS}" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} ${CXXFLAGS} ${LDFLAGS}" ) + SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} ${CFLAGS} ${CFLAGS_EXTRA}" ) + SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} ${CXXFLAGS} ${CXXFLAGS_EXTRA}" ) + SET(CMAKE_Fortran_FLAGS " ${CMAKE_Fortran_FLAGS} ${FFLAGS} ${FFLAGS_EXTRA}" ) ENDMACRO() -# Macro to set the flags for debug mode -MACRO( SET_COMPILE_FLAGS ) - ADD_USER_FLAGS() - IF ( ${CMAKE_BUILD_TYPE} STREQUAL "Debug" ) - IF ( NOT DISABLE_GXX_DEBUG ) - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -D_GLIBCXX_DEBUG" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -D_GLIBCXX_DEBUG" ) - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -D_GLIBCXX_DEBUG_PEDANTIC" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -D_GLIBCXX_DEBUG_PEDANTIC" ) - ENDIF () - IF ( USING_MICROSOFT ) - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -DDEBUG /DEBUG /Od" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -DDEBUG /DEBUG /Od" ) - SET(CONFIGURATION Debug ) - ELSE() - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -DDEBUG -g -O0" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -DDEBUG -g -O0" ) - ENDIF() - ELSEIF ( ${CMAKE_BUILD_TYPE} STREQUAL "Release" ) - IF ( USING_MICROSOFT ) - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} /O3" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} /O3" ) - SET(CONFIGURATION Release ) - ELSE() - SET(CMAKE_C_FLAGS " ${CMAKE_C_FLAGS} -O3" ) - SET(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -O3" ) - ENDIF() - ELSE() - MESSAGE(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}") +# Macro to add user c++ std +MACRO( ADD_CXX_STD ) + IF ( NOT CXX_STD ) + MESSAGE( FATAL_ERROR "The desired c++ standard must be specified: CXX_STD=(98,11,14,NONE)") + ENDIF() + IF ( ${CXX_STD} STREQUAL "NONE" ) + # Do nothing + return() + ELSEIF ( (NOT ${CXX_STD} STREQUAL "98") AND (NOT ${CXX_STD} STREQUAL "11") AND (NOT ${CXX_STD} STREQUAL "14") ) + MESSAGE( FATAL_ERROR "Unknown c++ standard (98,11,14,NONE)" ) + ENDIF() + # Add the flags + ADD_DEFINITIONS( -DCXX_STD=${CXX_STD} ) + SET( CMAKE_CXX_STANDARD ${CXX_STD} ) + MESSAGE( "C++ standard: ${CXX_STD}" ) + IF ( USING_GCC ) + # GNU: -std= + IF ( ${CXX_STD} STREQUAL "98" ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98") + ELSEIF ( ${CXX_STD} STREQUAL "11" ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") + ELSEIF ( ${CXX_STD} STREQUAL "14" ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y") + ENDIF() + ELSEIF ( USING_MSVC ) + # Microsoft: Does not support this level of control + ELSEIF ( USING_ICC ) + # ICC: -std= + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++${CXX_STD}") + ELSEIF ( USING_CRAY ) + # Cray: Does not seem to support controlling the std? + ELSEIF ( USING_PGCC ) + # PGI: -std= + IF ( ${CXX_STD} STREQUAL "98" ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --c++0x") + ELSEIF ( ${CXX_STD} STREQUAL "11" ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --c++11") + ELSEIF ( ${CXX_STD} STREQUAL "14" ) + MESSAGE( FATAL_ERROR "C++14 features are not availible yet for PGI" ) + ENDIF() + ELSEIF ( USING_CLANG ) + # Clang: -std= + IF ( ( ${CXX_STD} STREQUAL "98") OR ( ${CXX_STD} STREQUAL "98" ) ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++${CXX_STD}") + ELSEIF ( ${CXX_STD} STREQUAL "14" ) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y") + ENDIF() + ELSEIF ( USING_DEFAULT ) + # Default: do nothing ENDIF() - SET_COMPILER_FLAGS() ENDMACRO() +# Macro to set the compile/link flags +MACRO( SET_COMPILER_FLAGS ) + # Initilaize the compiler + IDENTIFY_COMPILER() + # Set the default flags for each build type + IF ( USING_MSVC ) + SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Zi /Z7" ) + SET(CMAKE_C_FLAGS_RELEASE "/O2 /EHsc /MD" ) + SET(CMAKE_CXX_FLAGS_DEBUG "-D_DEBUG /DEBUG /Od /EHsc /MDd /Zi /Z7" ) + SET(CMAKE_CXX_FLAGS_RELEASE "/O2 /EHsc /MD" ) + SET(CMAKE_Fortran_FLAGS_DEBUG "" ) + SET(CMAKE_Fortran_FLAGS_RELEASE "" ) + ELSE() + SET(CMAKE_C_FLAGS_DEBUG "-g -D_DEBUG -O0" ) + SET(CMAKE_C_FLAGS_RELEASE "-O2" ) + SET(CMAKE_CXX_FLAGS_DEBUG "-g -D_DEBUG -O0" ) + SET(CMAKE_CXX_FLAGS_RELEASE "-O2" ) + SET(CMAKE_Fortran_FLAGS_DEBUG "-g -O0" ) + SET(CMAKE_Fortran_FLAGS_RELEASE "-O2" ) + ENDIF() + # Set the compiler flags to use + IF ( ${CMAKE_BUILD_TYPE} STREQUAL "Debug" OR ${CMAKE_BUILD_TYPE} STREQUAL "DEBUG") + SET(CMAKE_C_FLAGS ${CMAKE_C_FLAGS_DEBUG} ) + SET(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_DEBUG} ) + SET(CMAKE_Fortran_FLAGS ${CMAKE_Fortran_FLAGS_DEBUG} ) + ELSEIF ( ${CMAKE_BUILD_TYPE} STREQUAL "Release" OR ${CMAKE_BUILD_TYPE} STREQUAL "RELEASE") + SET(CMAKE_C_FLAGS ${CMAKE_C_FLAGS_RELEASE} ) + SET(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_RELEASE} ) + SET(CMAKE_Fortran_FLAGS ${CMAKE_Fortran_FLAGS_RELEASE} ) + ELSEIF ( ${CMAKE_BUILD_TYPE} STREQUAL "RelWithDebInfo" OR ${CMAKE_BUILD_TYPE} STREQUAL "RELWITHDEBINFO") + SET(CMAKE_C_FLAGS "-g ${CMAKE_C_FLAGS_RELEASE}" ) + SET(CMAKE_CXX_FLAGS "-g ${CMAKE_CXX_FLAGS_RELEASE}" ) + SET(CMAKE_Fortran_FLAGS "-g ${CMAKE_Fortran_FLAGS_RELEASE}" ) + ELSE() + MESSAGE(FATAL_ERROR "Unknown value for CMAKE_BUILD_TYPE = ${CMAKE_BUILD_TYPE}") + ENDIF() + # Set the behavior of GLIBCXX flags + CHECK_ENABLE_FLAG( ENABLE_GXX_DEBUG 0 ) + IF ( ENABLE_GXX_DEBUG ) + # Enable GLIBCXX_DEBUG flags + SET( CMAKE_C_FLAGS_DEBUG " ${CMAKE_C_FLAGS_DEBUG} -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC" ) + SET( CMAKE_CXX_FLAGS_DEBUG " ${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC" ) + SET( DISABLE_GXX_DEBUG OFF ) + ELSEIF ( DISABLE_GXX_DEBUG ) + # Disable GLIBCXX_DEBUG flags + SET( DISABLE_GXX_DEBUG OFF ) + ELSE() + # Default + SET( DISABLE_GXX_DEBUG ON ) + ENDIF() + # Add the user flags + ADD_USER_FLAGS() + # Add the c++ standard flags + ADD_CXX_STD() + # Set the warnings to use + SET_WARNINGS() + # Test the compile flags + CHECK_C_COMPILER_FLAG( "${CMAKE_C_FLAGS}" CHECK_C_FLAGS ) + CHECK_CXX_COMPILER_FLAG( "${CMAKE_CXX_FLAGS}" CHECK_CXX_FLAGS ) + IF ( ( NOT CHECK_C_FLAGS ) OR ( NOT CHECK_CXX_FLAGS ) ) + IF ( USING_CRAY ) + MESSAGE(WARNING "Invalid C/CXX flags detected:" + "C flags: ${CMAKE_C_FLAGS}" "CXX flags: ${CMAKE_CXX_FLAGS}" ) + ENDIF() + ENDIF() +ENDMACRO() + + +# Macro to copy data file at build time +MACRO( COPY_DATA_FILE SRC_FILE DST_FILE ) + STRING(REGEX REPLACE "${${PROJ}_SOURCE_DIR}/" "" COPY_TARGET "copy-${PROJ}-${CMAKE_CURRENT_SOURCE_DIR}" ) + STRING(REGEX REPLACE "-${${PROJ}_SOURCE_DIR}" "" COPY_TARGET "${COPY_TARGET}" ) + STRING(REGEX REPLACE "/" "-" COPY_TARGET ${COPY_TARGET} ) + IF ( NOT TARGET ${COPY_TARGET} ) + ADD_CUSTOM_TARGET( ${COPY_TARGET} ALL ) + ADD_DEPENDENCIES( copy-${PROJ}-Data ${COPY_TARGET} ) + ENDIF() + ADD_CUSTOM_COMMAND( TARGET ${COPY_TARGET} + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${DST_FILE}" + DEPENDS "${SRC_FILE}" + ) +ENDMACRO() + + +# Macro to copy a data or input file +FUNCTION( COPY_TEST_FILE FILENAME ${ARGN} ) + SET( SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}" ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${CMAKE_CURRENT_SOURCE_DIR}/data" ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${CMAKE_CURRENT_SOURCE_DIR}/inputs" ) + FOREACH( tmp ${ARGN} ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${tmp}" ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${CMAKE_CURRENT_SOURCE_DIR}/${tmp}" ) + ENDFOREACH() + SET( FILE_TO_COPY ) + FOREACH( tmp ${SEARCH_PATHS} ) + IF ( EXISTS "${tmp}/${FILENAME}" ) + SET( FILE_TO_COPY "${tmp}/${FILENAME}" ) + ENDIF() + ENDFOREACH() + IF ( FILE_TO_COPY ) + SET( DESTINATION_NAME "${CMAKE_CURRENT_BINARY_DIR}/${FILENAME}" ) + COPY_DATA_FILE( ${FILE_TO_COPY} ${DESTINATION_NAME} ) + ELSE() + SET( MSG_STR "Cannot find file: ${FILENAME}, searched:\n" ) + FOREACH( tmp ${SEARCH_PATHS} ) + SET( MSG_STR "${MSG_STR} ${tmp}\n" ) + ENDFOREACH() + MESSAGE( WARNING "test ${MSG_STR}" ) + ENDIF() +ENDFUNCTION() + + +# Macro to copy a data file +FUNCTION( RENAME_TEST_FILE SRC_NAME DST_NAME ${ARGN} ) + SET( SEARCH_PATHS "${CMAKE_CURRENT_SOURCE_DIR}" ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${CMAKE_CURRENT_SOURCE_DIR}/data" ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${CMAKE_CURRENT_SOURCE_DIR}/inputs" ) + FOREACH( tmp ${ARGN} ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${tmp}" ) + SET( SEARCH_PATHS ${SEARCH_PATHS} "${CMAKE_CURRENT_SOURCE_DIR}/${tmp}" ) + ENDFOREACH() + SET( FILE_TO_COPY ) + FOREACH( tmp ${SEARCH_PATHS} ) + IF ( EXISTS "${tmp}/${SRC}" ) + SET( FILE_TO_COPY "${tmp}/${SRC_NAME}" ) + ENDIF() + ENDFOREACH() + IF ( FILE_TO_COPY ) + SET( DESTINATION_NAME ${CMAKE_CURRENT_BINARY_DIR}/${DST_NAME} ) + COPY_DATA_FILE( ${FILE_TO_COPY} ${DESTINATION_NAME} ) + ELSE() + SET( MSG_STR "Cannot find file: ${SRC_NAME}, searched:\n" ) + FOREACH( tmp ${SEARCH_PATHS} ) + SET( MSG_STR "${MSG_STR} ${tmp}\n" ) + ENDFOREACH() + MESSAGE( WARNING "test ${MSG_STR}" ) + ENDIF() +ENDFUNCTION() + + +# Macro to copy a data file +FUNCTION( COPY_EXAMPLE_DATA_FILE FILENAME ) + SET( FILE_TO_COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/${FILENAME} ) + SET( DESTINATION1 ${CMAKE_CURRENT_BINARY_DIR}/${FILENAME} ) + SET( DESTINATION2 ${EXAMPLE_INSTALL_DIR}/${FILENAME} ) + IF ( EXISTS ${FILE_TO_COPY} ) + COPY_DATA_FILE( ${FILE_TO_COPY} ${DESTINATION1} ) + COPY_DATA_FILE( ${FILE_TO_COPY} ${DESTINATION2} ) + ELSE() + MESSAGE( WARNING "Cannot find file: " ${FILE_TO_COPY} ) + ENDIF() +ENDFUNCTION() # Macro to add the dependencies and libraries to an executable @@ -293,32 +596,41 @@ MACRO( ADD_PROJ_EXE_DEP EXE ) # Add the executable to the dependencies of check and build-test ADD_DEPENDENCIES( check ${EXE} ) ADD_DEPENDENCIES( build-test ${EXE} ) + # Add the file copy targets to the dependency list + IF ( TARGET copy-${PROJ}-Data ) + ADD_DEPENDENCIES( ${EXE} copy-${PROJ}-Data ) + ENDIF() # Add the project libraries - TARGET_LINK_LIBRARIES( ${EXE} ${${PROJ}_LIBS} ) + TARGET_LINK_LIBRARIES( ${EXE} ${${PROJ}_LIBS} ${${PROJ}_LIBS} ) + TARGET_LINK_LIBRARIES( ${EXE} ${${PROJECT_NAME}_LIBRARIES} ) # Add external libraries - TARGET_LINK_LIBRARIES( ${EXE} ${TIMER_LIBS} ) + SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS}" ) + SET_TARGET_PROPERTIES( ${EXE} PROPERTIES LINK_FLAGS "${LDFLAGS_EXTRA}" ) + TARGET_LINK_LIBRARIES( ${EXE} ${LINK_LIBRARIES} ) + TARGET_LINK_LIBRARIES( ${EXE} ${CUDA_LIBS} ) TARGET_LINK_LIBRARIES( ${EXE} ${EXTERNAL_LIBS} ) - IF ( USE_MPI ) + IF ( USE_MPI OR USE_EXT_MPI OR HAVE_MPI ) TARGET_LINK_LIBRARIES( ${EXE} ${MPI_LINK_FLAGS} ${MPI_LIBRARIES} ) ENDIF() - TARGET_LINK_LIBRARIES( ${EXE} ${LAPACK_LIBS} ${BLAS_LIBS} ) - TARGET_LINK_LIBRARIES( ${EXE} ${COVERAGE_LIBS} ${SYSTEM_LIBS} ${LDLIBS} ) + TARGET_LINK_LIBRARIES( ${EXE} ${LAPACK_LIBS} ${BLAS_LIBS} ${BLAS_LAPACK_LIBS} ) + TARGET_LINK_LIBRARIES( ${EXE} ${COVERAGE_LIBS} ${LDLIBS} ${LDLIBS_EXTRA} ) + TARGET_LINK_LIBRARIES( ${EXE} ${SYSTEM_LIBS} ${SYSTEM_LDFLAGS} ) ENDMACRO() -# Add a executable -MACRO( INSTALL_${PROJ}_EXE EXE ) - SET( SOURCES ${EXE}.cpp ) - ADD_EXECUTABLE( ${EXE} ${SOURCES} ) - ADD_PROJ_EXE_DEP( ${EXE} ) - INSTALL( TARGETS ${EXE} DESTINATION ${LBPM_INSTALL_DIR}/bin ) -ENDMACRO() +# Check if we want to keep the test +FUNCTION( KEEP_TEST RESULT ) + SET( ${RESULT} 1 PARENT_SCOPE ) +ENDFUNCTION() # Add a provisional test FUNCTION( ADD_PROJ_PROVISIONAL_TEST EXEFILE ) # Check if we actually want to add the test - SET( EXCLUDE_TESTS_FROM_ALL 0 ) + KEEP_TEST( RESULT ) + IF ( NOT RESULT ) + RETURN() + ENDIF() # Check if test has already been added SET( tmp ) IF ( TARGET ${EXEFILE} ) @@ -327,8 +639,9 @@ FUNCTION( ADD_PROJ_PROVISIONAL_TEST EXEFILE ) ENDIF() IF ( NOT tmp ) # The target has not been added - SET( CXXFILE ${EXEFILE}.cpp ) + SET( CXXFILE ${EXEFILE} ) SET( TESTS_SO_FAR ${TESTS_SO_FAR} ${EXEFILE} ) + # Check if we want to add the test to all IF ( NOT EXCLUDE_TESTS_FROM_ALL ) ADD_EXECUTABLE( ${EXEFILE} ${CXXFILE} ) ELSE() @@ -357,64 +670,110 @@ FUNCTION( ADD_${PROJ}_PROVISIONAL_TEST EXEFILE ) ENDFUNCTION() - # Macro to create the test name MACRO( CREATE_TEST_NAME TEST ${ARGN} ) - SET( TESTNAME "${TEST}" ) - FOREACH( tmp ${ARGN} ) + IF ( PACKAGE ) + SET( TESTNAME "${PACKAGE}::${TEST}" ) + ELSE() + SET( TESTNAME "${TEST}" ) + ENDIF() + FOREACH( tmp ${ARGN}) SET( TESTNAME "${TESTNAME}--${tmp}") endforeach() # STRING(REGEX REPLACE "--" "-" TESTNAME ${TESTNAME} ) ENDMACRO() +# Function to add the resource locks to an executable +FUNCTION( ADD_RESOURCE_LOCK TESTNAME EXEFILE ${ARGN} ) + IF ( NOT ARGN ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) + ELSE() + FOREACH( tmp ${ARGN} ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${tmp} ) + ENDFOREACH() + ENDIF() +ENDFUNCTION() + + # Add a executable as a test FUNCTION( ADD_${PROJ}_TEST EXEFILE ${ARGN} ) + # Check if we actually want to add the test + KEEP_TEST( RESULT ) + IF ( NOT RESULT ) + RETURN() + ENDIF() + # Add the provisional test ADD_PROJ_PROVISIONAL_TEST ( ${EXEFILE} ) CREATE_TEST_NAME( ${EXEFILE} ${ARGN} ) GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) - IF ( USE_EXT_MPI_FOR_SERIAL_TESTS ) + IF ( USE_MPI_FOR_SERIAL_TESTS ) ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} 1 ${EXE} ${ARGN} ) ELSE() ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) ENDIF() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) + ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ENDFUNCTION() # Add a executable as a weekly test FUNCTION( ADD_${PROJ}_WEEKLY_TEST EXEFILE PROCS ${ARGN} ) + # Check if we actually want to add the test + KEEP_TEST( RESULT ) + IF ( NOT RESULT ) + RETURN() + ENDIF() + # Add the provisional test ADD_PROJ_PROVISIONAL_TEST ( ${EXEFILE} ) GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) IF( ${PROCS} STREQUAL "1" ) CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} ) - IF( USE_EXT_MPI_FOR_SERIAL_TESTS ) + ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) + CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs_WEEKLY" ${ARGN} ) + ENDIF() + IF ( ${PROCS} GREATER ${TEST_MAX_PROCS} ) + MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS})") + ELSEIF( ${PROCS} STREQUAL "1" ) + CREATE_TEST_NAME( "${EXEFILE}_WEEKLY" ${ARGN} ) + IF ( USE_MPI_FOR_SERIAL_TESTS ) ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} 1 ${EXE} ${ARGN} ) ELSE() ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) ENDIF() - ELSEIF( USE_MPI AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) + ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) + ELSEIF( (USE_MPI OR USE_EXT_MPI) AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs_WEEKLY" ${ARGN} ) ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) + ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ENDIF() - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) ENDFUNCTION() # Add a executable as a parallel test FUNCTION( ADD_${PROJ}_TEST_PARALLEL EXEFILE PROCS ${ARGN} ) - ADD_PROJ_PROVISIONAL_TEST ( ${EXEFILE} ) + # Check if we actually want to add the test + KEEP_TEST( RESULT ) + IF ( NOT RESULT ) + RETURN() + ENDIF() + # Add the provisional test + ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) - IF ( USE_MPI ) - CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs" ${ARGN} ) + CREATE_TEST_NAME( "${EXEFILE}_${PROCS}procs" ${ARGN} ) + IF ( NOT ( USE_MPI OR USE_EXT_MPI ) ) + MESSAGE("Disabling test ${TESTNAME} (configured without MPI)") + ELSEIF ( ${PROCS} GREATER ${TEST_MAX_PROCS} ) + MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS})") + ELSE() ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) + ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ENDIF() ENDFUNCTION() @@ -429,63 +788,78 @@ MACRO( ADD_${PROJ}_TEST_THREAD_MPI EXEFILE PROCS THREADS ${ARGN} ) MATH( EXPR TOT_PROCS "${PROCS} * ${THREADS}" ) IF ( ${TOT_PROCS} GREATER ${TEST_MAX_PROCS} ) MESSAGE("Disabling test ${TESTNAME} (exceeds maximum number of processors ${TEST_MAX_PROCS}") - ELSEIF ( ( ${PROCS} STREQUAL "1" ) AND NOT USE_EXT_MPI_FOR_SERIAL_TESTS ) + ELSEIF ( ( ${PROCS} STREQUAL "1" ) AND NOT USE_MPI_FOR_SERIAL_TESTS ) ADD_TEST ( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE} ${ARGN} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) - ELSEIF ( USE_MPI ) + SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) + ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) + ELSEIF ( USE_MPI OR USE_EXT_MPI ) ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) + SET_TESTS_PROPERTIES ( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${TOT_PROCS} ) + ADD_RESOURCE_LOCK( ${TESTNAME} ${EXEFILE} ${ARGN} ) ENDIF() ENDMACRO() -# Copy an example folder -MACRO( INSTALL_EXAMPLE EXAMPLE ) - INSTALL( DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${EXAMPLE}" DESTINATION "${LBPM_INSTALL_DIR}/example" ) -ENDMACRO() - - -# Create an example test -CONFIGURE_FILE( "${${PROJ}_SOURCE_DIR}/cmake/CompareOutput.cmake" "${${PROJ}_BUILD_DIR}/CompareOutput.cmake" COPYONLY ) -MACRO( TEST_EXAMPLE EXAMPLE EXEFILE PROCS ${ARGN} ) - SET( EXAMPLE_DIR "${CMAKE_CURRENT_BINARY_DIR}/${EXAMPLE}" ) - # Copy the example directory - ADD_CUSTOM_TARGET( - ${EXAMPLE} ALL - ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_SOURCE_DIR}/${EXAMPLE}" "${EXAMPLE_DIR}" - DEPENDS ${EXEFILE} - ) - # Create a wrapper script to run the test and copy the output to ${EXAMPLE}.out - SET( FILENAME "${EXAMPLE_DIR}/run-${EXAMPLE}" ) - FILE(WRITE "${FILENAME}" "# This is a automatically generated file to run example--${EXAMPLE}\n" ) - FILE(APPEND "${FILENAME}" "${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} \"${LBPM_INSTALL_DIR}/bin/${EXEFILE}\" ${ARGN} 2>&1 | tee ${EXAMPLE}.out\n\n" ) - # Create the test to run the example - SET( TESTNAME example--${EXAMPLE} ) - EXECUTE_PROCESS(COMMAND chmod 755 "${FILENAME}") - ADD_TEST( - NAME ${TESTNAME} - WORKING_DIRECTORY "${EXAMPLE_DIR}" - COMMAND "${FILENAME}" +# Add a executable as an example +FUNCTION( ADD_${PROJ}_EXAMPLE EXEFILE PROCS ${ARGN} ) + # Add the file to the example doxygen file + SET( VALUE 0 ) + FOREACH(_variableName ${EXAMPLE_LIST}) + IF ( "${_variableName}" STREQUAL "${EXEFILE}" ) + SET( VALUE 1 ) + ENDIF() + ENDFOREACH() + IF ( NOT ${VALUE} ) + FILE(APPEND ${EXAMPLE_INSTALL_DIR}/examples.h "* \\ref ${EXEFILE} \"${EXEFILE}\"\n" ) + SET( EXAMPLE_LIST ${EXAMPLE_LIST} ${EXEFILE} CACHE INTERNAL "example_list" FORCE ) + ENDIF() + # Check if we actually want to add the test + IF ( ONLY_BUILD_DOCS ) + RETURN() + ENDIF() + # Add the provisional test + ADD_PROJ_PROVISIONAL_TEST( ${EXEFILE} ) + GET_TARGET_PROPERTY(EXE ${EXEFILE} LOCATION) + STRING(REGEX REPLACE "\\$\\(Configuration\\)" "${CONFIGURATION}" EXE "${EXE}" ) + ADD_DEPENDENCIES( build-examples ${EXEFILE} ) + GET_TARGET_PROPERTY(EXE2 ${EXEFILE} LOCATION) + ADD_CUSTOM_COMMAND( TARGET ${EXEFILE} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${EXE2} "${EXAMPLE_INSTALL_DIR}/${EXEFILE}" ) + IF( ${PROCS} STREQUAL "1" AND (NOT USE_MPI_FOR_SERIAL_TESTS) ) + CREATE_TEST_NAME( "example--${EXEFILE}" ${ARGN} ) + ADD_TEST( ${TESTNAME} ${EXE} ${ARGN} ) + ELSEIF ( USE_EXT_MPI AND NOT (${PROCS} GREATER ${TEST_MAX_PROCS}) ) + CREATE_TEST_NAME( "example--${EXEFILE}_${PROCS}procs" ${ARGN} ) + ADD_TEST( ${TESTNAME} ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} ${PROCS} ${EXE} ${ARGN} ) + ENDIF() SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS ${PROCS} ) SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES RESOURCE_LOCK ${EXEFILE} ) - # Create a test that checks the output against the data in EXAMPLE/OutputAns.txt - IF ( EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${EXAMPLE}/ExampleOutput.txt" ) - ADD_TEST( - NAME ${TESTNAME}-output - WORKING_DIRECTORY "${EXAMPLE_DIR}" - COMMAND ${CMAKE_COMMAND} -DTEST=${EXAMPLE}.out -DGOLD=ExampleOutput.txt -P "${${PROJ}_BUILD_DIR}/CompareOutput.cmake" - ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES FAIL_REGULAR_EXPRESSION "${TEST_FAIL_REGULAR_EXPRESSION}" PROCESSORS 1 ) - SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES DEPENDS ${TESTNAME} ) - ENDIF() +ENDFUNCTION() + + +# Begin configure for the examples for a package +MACRO( BEGIN_EXAMPLE_CONFIG PACKAGE ) + # Set example install dir + SET( EXAMPLE_INSTALL_DIR ${${PROJ}_INSTALL_DIR}/examples/${PACKAGE} ) + # Create list of examples + SET( EXAMPLE_LIST "dummy" CACHE INTERNAL "example_list" FORCE ) + # Create doxygen input file for examples + SET( DOXYFILE_EXTRA_SOURCES ${DOXYFILE_EXTRA_SOURCES} ${EXAMPLE_INSTALL_DIR} CACHE INTERNAL "doxyfile_extra_sources") + FILE(WRITE ${EXAMPLE_INSTALL_DIR}/examples.h "// Include file for doxygen providing the examples for ${PACKAGE}\n") + FILE(APPEND ${EXAMPLE_INSTALL_DIR}/examples.h "/*! \\page Examples_${PACKAGE}\n" ) +ENDMACRO() + + +# Install the examples +MACRO( INSTALL_${PROJ}_EXAMPLE PACKAGE ) + FILE(APPEND ${EXAMPLE_INSTALL_DIR}/examples.h "*/\n" ) + SET( EXAMPLE_INSTALL_DIR "" ) ENDMACRO() # Macro to check if a flag is enabled -MACRO ( CHECK_ENABLE_FLAG FLAG DEFAULT ) +MACRO( CHECK_ENABLE_FLAG FLAG DEFAULT ) IF( NOT DEFINED ${FLAG} ) SET( ${FLAG} ${DEFAULT} ) ELSEIF( ${FLAG} STREQUAL "" ) @@ -496,52 +870,135 @@ MACRO ( CHECK_ENABLE_FLAG FLAG DEFAULT ) SET( ${FLAG} 1 ) ELSE() MESSAGE( "Bad value for ${FLAG} (${${FLAG}}); use true or false" ) - ENDIF () + ENDIF() ENDMACRO() -# Macro to check if a compiler flag is valid -MACRO (CHECK_C_COMPILER_FLAG _FLAG _RESULT) - SET(SAFE_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") - SET(CMAKE_REQUIRED_DEFINITIONS "${_FLAG}") - CHECK_C_SOURCE_COMPILES("int main() { return 0;}" ${_RESULT} - # Some compilers do not fail with a bad flag - FAIL_REGEX "error: bad value (.*) for .* switch" # GNU - FAIL_REGEX "argument unused during compilation" # clang - FAIL_REGEX "is valid for .* but not for C" # GNU - FAIL_REGEX "unrecognized .*option" # GNU - FAIL_REGEX "ignoring unknown option" # MSVC - FAIL_REGEX "[Uu]nknown option" # HP - FAIL_REGEX "[Ww]arning: [Oo]ption" # SunPro - FAIL_REGEX "command option .* is not recognized" # XL - FAIL_REGEX "WARNING: unknown flag:" # Open64 - FAIL_REGEX " #10159: " # ICC - ) - SET(CMAKE_REQUIRED_DEFINITIONS "${SAFE_CMAKE_REQUIRED_DEFINITIONS}") -ENDMACRO(CHECK_C_COMPILER_FLAG) - - # Macro to add a latex file to the build -MACRO (ADD_LATEX_DOCS FILE) +MACRO( ADD_LATEX_DOCS FILE ) GET_FILENAME_COMPONENT(LATEX_TARGET ${FILE} NAME_WE) ADD_CUSTOM_TARGET( ${LATEX_TARGET}_pdf ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${FILE} ${CMAKE_CURRENT_BINARY_DIR}/. - COMMAND pdflatex -interaction=batchmode -draftmode ${FILE} - #COMMAND bibtex -terse ${LATEX_TARGET} - COMMAND pdflatex -interaction=batchmode ${FILE} + COMMAND pdflatex -interaction=batchmode -draftmode ${FILE} ";" echo "" + COMMAND bibtex -terse ${LATEX_TARGET} ";" echo "" + COMMAND pdflatex -interaction=batchmode ${FILE} ";" echo "" SOURCES ${FILE} ) ADD_CUSTOM_COMMAND( TARGET ${LATEX_TARGET}_pdf POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/${LATEX_TARGET}.pdf ${AMR_MHD_INSTALL_DIR}/doc/. + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/${LATEX_TARGET}.pdf ${${PROJ}_INSTALL_DIR}/doc/. WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ) ADD_DEPENDENCIES( latex_docs ${LATEX_TARGET}_pdf ) ENDMACRO() +# Add a matlab mex file +FUNCTION( ADD_MATLAB_MEX MEXFILE ) + # Set the MEX compiler and default link flags + IF ( USING_MSVC ) + #SET(MEX_FLAGS ${MEX_FLAGS} "LINKFLAGS=\"/NODEFAULTLIB:MSVSRT.lib\"" ) + SET( MEX "\"${MATLAB_DIRECTORY}/sys/perl/win32/bin/perl.exe\" \"${MATLAB_DIRECTORY}/bin/mex.pl\"" ) + SET( MEX_LDFLAGS ${MEX_LDFLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/.. + -L${CMAKE_CURRENT_BINARY_DIR}/../Debug -L${CMAKE_CURRENT_BINARY_DIR} ) + FOREACH( rpath ${CMAKE_INSTALL_RPATH} ) + #SET( MEX_LDFLAGS ${MEX_LDFLAGS} "-Wl,-rpath,${rpath},--no-undefined" ) + ENDFOREACH() + ELSE() + SET( MEX mex ) + FOREACH( rpath ${CMAKE_INSTALL_RPATH} ) + SET( MEX_LDFLAGS ${MEX_LDFLAGS} "-Wl,-rpath,${rpath},--no-undefined" ) + ENDFOREACH() + ENDIF() + SET( MEX_LDFLAGS ${MEX_LDFLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/.. ${SYSTEM_LDFLAGS} ) + SET( MEX_LIBS ${MEX_LIBS} ${SYSTEM_LIBS} ) + # Create the mex comamnd + STRING(REGEX REPLACE "[.]cpp" "" TARGET ${MEXFILE}) + STRING(REGEX REPLACE "[.]c" "" TARGET ${TARGET}) + FILE(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}" ) + IF ( USING_MSVC ) + SET( MEX_BAT_FILE "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/compile_mex.bat" ) + FILE( WRITE "${MEX_BAT_FILE}" "${MEX} \"${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE}\" " ) + APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_FLAGS}" "\"" "\" " ) + APPEND_LIST( "${MEX_BAT_FILE}" "${COMPFLAGS}" "\"" "\" " ) + APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_INCLUDE}" "\"" "\" " ) + APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_LDFLAGS}" "\"" "\" " ) + APPEND_LIST( "${MEX_BAT_FILE}" "${MEX_LIBS}" "\"" "\" " ) + APPEND_LIST( "${MEX_BAT_FILE}" "${COVERAGE_MATLAB_LIBS}" "\"" "\" " ) + SET( MEX_COMMAND "${MEX_BAT_FILE}" ) + ELSE() + STRING(REPLACE " " ";" MEX_CFLAGS "$$CFLAGS ${CMAKE_C_FLAGS}") + STRING(REPLACE " " ";" MEX_CXXFLAGS "$$CXXFLAGS ${CMAKE_CXX_FLAGS}") + SET( MEX_COMMAND ${MEX} ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE} + ${MEX_FLAGS} ${MEX_INCLUDE} + CFLAGS="${MEX_CFLAGS}" + CXXFLAGS="${MEX_CXXFLAGS}" + LDFLAGS="${MEX_LDFLAGS}" + ${MEX_LIBS} ${COVERAGE_MATLAB_LIBS} + ) + ENDIF() + ADD_CUSTOM_COMMAND( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} + COMMAND ${MEX_COMMAND} + COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/${TARGET}.${MEX_EXTENSION}" "${CMAKE_CURRENT_BINARY_DIR}" + COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET}/${TARGET}.${MEX_EXTENSION}" "${${PROJ}_INSTALL_DIR}/matlab" + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/temp/${TARGET} + DEPENDS ${${PROJ}_LIBS} ${MATLAB_TARGET} ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE} + ) + ADD_CUSTOM_TARGET( ${TARGET} + DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} + DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${MEXFILE} + ) + ADD_DEPENDENCIES( ${TARGET} ${${PROJ}_LIBS} ${MATLAB_TARGET} ) + ADD_DEPENDENCIES( mex ${TARGET} ) + INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.${MEX_EXTENSION} DESTINATION ${${PROJ}_INSTALL_DIR}/mex ) +ENDFUNCTION() + + +# Add a matlab test +MACRO( ADD_MATLAB_TEST EXEFILE ${ARGN} ) + FIND_PROGRAM( MATLAB_EXE NAME matlab ) + CONFIGURE_FILE( ${EXEFILE}.m ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.m ) + CREATE_TEST_NAME( MATLAB ${EXEFILE} ${ARGN} ) + IF ( USING_MSVC ) + SET( MATLAB_OPTIONS "-nodisplay" "-nodesktop" "-wait" "-logfile" "log_${EXEFILE}" ) + ELSE() + SET( MATLAB_OPTIONS "-nojvm -nosplash -nodisplay" ) + ENDIF() + SET( MATLAB_COMMAND "addpath('${${PROJ}_BINARY_DIR}/matlab'); try, ${EXEFILE}, catch ME, ME, exit(1), end, disp('ALL TESTS PASSED'); exit(0)" ) + SET( MATLAB_DEBUGGER_OPTIONS ) + IF ( MATLAB_DEBUGGER ) + SET( MATLAB_DEBUGGER_OPTIONS -D${MATLAB_DEBUGGER} ) + STRING(REPLACE "\"" "" MATLAB_DEBUGGER_OPTIONS "${MATLAB_DEBUGGER_OPTIONS}") + ENDIF() + IF ( USING_MSVC ) + FILE( WRITE "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat" "@echo off\n") + FILE( APPEND "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat" "matlab ") + APPEND_LIST( "${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat" "${MATLAB_OPTIONS}" "" " " ) + FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat " -r \"${MATLAB_COMMAND}\" ${MATLAB_DEBUGGER_OPTIONS}\n" ) + FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat "@echo on\n") + FILE(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat "type log_${EXEFILE}\n" ) + ADD_TEST( ${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${EXEFILE}.bat ) + ELSE() + ADD_TEST( ${TESTNAME} matlab ${MATLAB_OPTIONS} -r "${MATLAB_COMMAND}" ${MATLAB_DEBUGGER_OPTIONS} ) + ENDIF() + SET_TESTS_PROPERTIES( ${TESTNAME} PROPERTIES PASS_REGULAR_EXPRESSION "ALL TESTS PASSED" FAIL_REGULAR_EXPRESSION "FAILED" ) + SET_PROPERTY(TEST ${TESTNAME} APPEND PROPERTY ENVIRONMENT RATES_DIRECTORY=${RATES_DIRECTORY} ) +ENDMACRO() + + +# Append a list to a file +FUNCTION( APPEND_LIST FILENAME VARS PREFIX POSTFIX ) + FOREACH( tmp ${VARS} ) + FILE( APPEND "${FILENAME}" "${PREFIX}" ) + FILE( APPEND "${FILENAME}" "${tmp}" ) + FILE( APPEND "${FILENAME}" "${POSTFIX}" ) + ENDFOREACH () +ENDFUNCTION() + + # add custom target distclean # cleans and removes cmake generated files etc. MACRO( ADD_DISTCLEAN ${ARGN} ) @@ -606,3 +1063,28 @@ MACRO( ADD_DISTCLEAN ${ARGN} ) ) ENDIF() ENDMACRO() + + +# add custom target mex_clean +MACRO( ADD_MEXCLEAN ) + IF (UNIX) + ADD_CUSTOM_TARGET( mexclean + COMMENT "mex clean" + COMMAND rm + ARGS -Rf libmatlab.* *.mex* test/*.mex* + ) + ENDIF(UNIX) +ENDMACRO() + + +# Print the current repo version and create target to write to a file +SET( WriteRepoVersionCmakeFile "${CMAKE_CURRENT_LIST_DIR}/WriteRepoVersion.cmake" ) +FUNCTION( WRITE_REPO_VERSION FILENAME ) + SET( CMD ${CMAKE_COMMAND} -Dfilename="${FILENAME}" -Dsrc_dir="${${PROJ}_SOURCE_DIR}" + -Dtmp_file="${CMAKE_CURRENT_BINARY_DIR}/tmp/version.h" -DPROJ=${PROJ} + -P "${WriteRepoVersionCmakeFile}" ) + EXECUTE_PROCESS( COMMAND ${CMD} ) + ADD_CUSTOM_TARGET( write_repo_version COMMENT "Write repo version" COMMAND ${CMD} ) +ENDFUNCTION() + + diff --git a/common/Domain.h b/common/Domain.h index a8308f28..03719d09 100755 --- a/common/Domain.h +++ b/common/Domain.h @@ -6,12 +6,12 @@ #include #include #include -#include #include #include #include // std::exception #include +#include "common/Array.h" #include "common/Utilities.h" #include "common/MPI_Helpers.h" #include "common/Communication.h" @@ -788,9 +788,9 @@ inline void SSO(DoubleArray &Distance, char *ID, Domain &Dm, int timesteps){ */ int Q=26; - int q,i,j,k,n; + int q,i,j,k; double dt=0.1; - int in,jn,kn,nn; + int in,jn,kn; double Dqx,Dqy,Dqz,Dx,Dy,Dz,W; double nx,ny,nz,Cqx,Cqy,Cqz,sign,norm; @@ -822,7 +822,6 @@ inline void SSO(DoubleArray &Distance, char *ID, Domain &Dm, int timesteps){ for (j=1;j0 ) { + while ( !feof(fid) && fgets(line,100,fid)!=NULL ) { char* line2 = line; List_cx[count] = strtod(line2,&line2); List_cy[count] = strtod(line2,&line2); diff --git a/common/TwoPhase.h b/common/TwoPhase.h index 46fc0e82..c343c17b 100644 --- a/common/TwoPhase.h +++ b/common/TwoPhase.h @@ -285,9 +285,9 @@ public: void TwoPhase::ColorToSignedDistance(double Beta, DoubleArray &ColorData, DoubleArray &DistData){ - double factor,temp,value; +/* double factor,temp,value; factor=0.5/Beta; -/* for (int n=0; n 0.999 ) DistData[n] = 4.0; else if (value < -0.999 ) DistData[n] = -4.0; @@ -568,7 +568,7 @@ void TwoPhase::ComputeLocal(){ void TwoPhase::AssignComponentLabels(){ int LabelNWP=1; - int LabelWP=2; + //int LabelWP=2; // NOTE: labeling the wetting phase components is tricky! One sandstone media had over 800,000 components //NumberComponents_WP = ComputeGlobalPhaseComponent(Dm.Nx-2,Dm.Ny-2,Dm.Nz-2,Dm.rank_info,PhaseID,LabelWP,Label_WP); // treat all wetting phase is connected @@ -826,6 +826,7 @@ void TwoPhase::ComponentAverages(){ van(1) = ComponentAverages_NWP(VY,b)/Vn; van(2) = ComponentAverages_NWP(VZ,b)/Vn; vsq = ComponentAverages_NWP(VSQ,b)/Vn; + NULL_USE(ans); if (ComponentAverages_NWP(TRIMVOL,b) > 0.0){ pn = ComponentAverages_NWP(PRS,b)/ComponentAverages_NWP(TRIMVOL,b); @@ -910,6 +911,7 @@ void TwoPhase::ComponentAverages(){ vaw(1) = ComponentAverages_WP(VY,b)/Vw; vaw(2) = ComponentAverages_WP(VZ,b)/Vw; vsq = ComponentAverages_WP(VSQ,b)/Vw; + NULL_USE(ans); if (ComponentAverages_WP(TRIMVOL,b) > 0.0){ pw = ComponentAverages_WP(PRS,b)/ComponentAverages_WP(TRIMVOL,b); @@ -975,7 +977,7 @@ void TwoPhase::ComponentAverages(){ void TwoPhase::WriteSurfaces(int logcount){ - int i,j,k,n; + int i,j,k; int ncubes=(Nx-1)*(Ny-1)*(Nz-1); Point P,A,B,C; @@ -1214,7 +1216,7 @@ void TwoPhase::PrintAll(int timestep){ void TwoPhase::PrintComponents(int timestep){ if (Dm.rank==0){ - printf("PRINT %i COMPONENT AVEREAGES: time = %i \n",ComponentAverages_NWP.size(1),timestep); + printf("PRINT %i COMPONENT AVEREAGES: time = %i \n",(int)ComponentAverages_NWP.size(1),timestep); for (int b=0; b 0.0){ fprintf(NWPLOG,"%i ",timestep-5); diff --git a/example/examples.h b/example/examples.h new file mode 100644 index 00000000..e9190779 --- /dev/null +++ b/example/examples.h @@ -0,0 +1,36 @@ +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" +* \ref Bubble "Bubble" +* \ref Sph1896 "Sph1896" +* \ref ConstrainedBubble "ConstrainedBubble" diff --git a/tests/BasicSimulator.cpp b/tests/BasicSimulator.cpp index a01b64d0..c594ae7e 100644 --- a/tests/BasicSimulator.cpp +++ b/tests/BasicSimulator.cpp @@ -6,10 +6,10 @@ #include #include -#include "pmmc.h" -#include "ScaLBL.h" +#include "common/pmmc.h" +#include "common/ScaLBL.h" #include "common/MPI_Helpers.h" -#include "Communication.h" +#include "common/Communication.h" //#define CBUB //#define WRITE_SURFACES @@ -123,14 +123,13 @@ int main(int argc, char **argv) // Variables that specify the computational domain string FILENAME; - unsigned int nBlocks, nthreads; int Nx,Ny,Nz; // local sub-domain size int nspheres; // number of spheres in the packing double Lx,Ly,Lz; // Domain length double D = 1.0; // reference length for non-dimensionalization // Color Model parameters int timestepMax, interval; - double tau,Fx,Fy,Fz,tol,err; + double tau,Fx,Fy,Fz,tol; double alpha, beta; double das, dbs, phi_s; double din,dout; @@ -146,8 +145,6 @@ int main(int argc, char **argv) int SimCount; // Number of simulations is 2 x SimCount double SimDelta; // Percent differenc between force pairs - int RESTART_INTERVAL=20000; - if (rank==0){ //............................................................. // READ SIMULATION PARMAETERS FROM INPUT FILE @@ -232,7 +229,8 @@ int main(int argc, char **argv) //................................................. MPI_Barrier(MPI_COMM_WORLD); - RESTART_INTERVAL=interval; + //int RESTART_INTERVAL=interval; + // ************************************************************** // ************************************************************** double Ps = -(das-dbs)/(das+dbs); @@ -1462,7 +1460,6 @@ int main(int argc, char **argv) } } - err = 1.0; sat_w_previous = 1.01; // slightly impossible value! if (rank==0) printf("Begin timesteps: error tolerance is %f \n", tol); for (int SimNumber=0; SimNumber < 2*SimCount; SimNumber++){ diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 02ce7239..fe187fa5 100755 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,21 +1,21 @@ # Copy files for the tests -INSTALL_LBPM_EXE( lb2_Color_wia_mpi ) -INSTALL_LBPM_EXE( lbpm_permeability_simulator ) -INSTALL_LBPM_EXE( lbpm_color_simulator ) -INSTALL_LBPM_EXE( lbpm_sphere_pp ) -INSTALL_LBPM_EXE( lbpm_random_pp ) -INSTALL_LBPM_EXE( lbpm_segmented_pp ) -INSTALL_LBPM_EXE( lbpm_segmented_decomp ) -INSTALL_LBPM_EXE( lbpm_disc_pp ) -INSTALL_LBPM_EXE( lbpm_captube_pp ) -INSTALL_LBPM_EXE( lbpm_BlobAnalysis ) -INSTALL_LBPM_EXE( TestBubble ) -INSTALL_LBPM_EXE( BasicSimulator ) -INSTALL_LBPM_EXE( ComponentLabel ) -INSTALL_LBPM_EXE( BlobAnalysis ) -INSTALL_LBPM_EXE( BlobIdentify ) -INSTALL_LBPM_EXE( BlobIdentifyParallel ) -#INSTALL_LBPM_EXE( BlobAnalyzeParallel ) +ADD_LBPM_EXECUTABLE( lb2_Color_wia_mpi ) +ADD_LBPM_EXECUTABLE( lbpm_permeability_simulator ) +ADD_LBPM_EXECUTABLE( lbpm_color_simulator ) +ADD_LBPM_EXECUTABLE( lbpm_sphere_pp ) +ADD_LBPM_EXECUTABLE( lbpm_random_pp ) +ADD_LBPM_EXECUTABLE( lbpm_segmented_pp ) +ADD_LBPM_EXECUTABLE( lbpm_segmented_decomp ) +ADD_LBPM_EXECUTABLE( lbpm_disc_pp ) +ADD_LBPM_EXECUTABLE( lbpm_captube_pp ) +ADD_LBPM_EXECUTABLE( lbpm_BlobAnalysis ) +ADD_LBPM_EXECUTABLE( TestBubble ) +ADD_LBPM_EXECUTABLE( BasicSimulator ) +ADD_LBPM_EXECUTABLE( ComponentLabel ) +ADD_LBPM_EXECUTABLE( BlobAnalysis ) +ADD_LBPM_EXECUTABLE( BlobIdentify ) +ADD_LBPM_EXECUTABLE( BlobIdentifyParallel ) +#ADD_LBPM_EXECUTABLE( BlobAnalyzeParallel ) CONFIGURE_FILE( ${CMAKE_CURRENT_SOURCE_DIR}/cylindertest ${CMAKE_CURRENT_BINARY_DIR}/cylindertest COPYONLY ) diff --git a/tests/ComponentLabel.cpp b/tests/ComponentLabel.cpp index efc3f1a6..c6365072 100644 --- a/tests/ComponentLabel.cpp +++ b/tests/ComponentLabel.cpp @@ -6,7 +6,7 @@ #include #include #include "analysis/analysis.h" -#include "TwoPhase.h" +#include "common/TwoPhase.h" #define NUM_AVERAGES 30 @@ -198,7 +198,7 @@ int main(int argc, char **argv) int nspheres; double Lx,Ly,Lz; //....................................................................... - int i,j,k,n,p,idx; + int i,j,k,n; int iproc,jproc,kproc; //....................................................................... // Reading the domain information file diff --git a/tests/TestBlobAnalyze.cpp b/tests/TestBlobAnalyze.cpp index 8ac409fa..07542f1b 100644 --- a/tests/TestBlobAnalyze.cpp +++ b/tests/TestBlobAnalyze.cpp @@ -7,10 +7,7 @@ #include #include "common/Communication.h" #include "analysis/analysis.h" -#ifdef PROFILE - #include "ProfilerApp.h" -#endif -#include "TwoPhase.h" +#include "common/TwoPhase.h" //#include "Domain.h" diff --git a/tests/TestBlobIdentifyCorners.cpp b/tests/TestBlobIdentifyCorners.cpp new file mode 100644 index 00000000..7138c89e --- /dev/null +++ b/tests/TestBlobIdentifyCorners.cpp @@ -0,0 +1,124 @@ +// Test of ComputeGlobalBlobIDs for special corner/edge cases +// Note: this is a short test, but requires 27 processors to run + +#include +#include +#include "common/pmmc.h" +#include "common/Communication.h" +#include "analysis/analysis.h" +#include "IO/MeshDatabase.h" +#include "IO/Reader.h" +#include "IO/Writer.h" +#include "ProfilerApp.h" + + + + +// Main +int main(int argc, char **argv) +{ + // Initialize MPI + int rank, nprocs; + MPI_Init(&argc,&argv); + MPI_Comm_rank(MPI_COMM_WORLD,&rank); + MPI_Comm_size(MPI_COMM_WORLD,&nprocs); + /*if ( nprocs != 8 ) { + printf("This tests requires 8 processors\n"); + return -1; + }*/ + if ( rank==0 ) { + printf("-----------------------------------------------------------\n"); + printf("Testing Blob Identification Special Cases\n"); + printf("-----------------------------------------------------------\n"); + } + + // Set the domain information + std::vector factors = Utilities::factor(nprocs); + int nproc[3]={1,1,1}; + for (size_t i=0; i fillData(rank_info,nx,ny,nz,1,1,1,0,1); + fillData.fill(Phase); + fillData.fill(SignDist); + + // Find blob domains + if ( rank==0 ) { printf("Finding blob domains\n"); } + double vF=0.0; + double vS=0.0; + IntArray LocalBlobID, GlobalBlobID; + int nblobs0 = ComputeLocalBlobIDs(Phase,SignDist,vF,vS,LocalBlobID,false); + int nblobs = ComputeGlobalBlobIDs(nx,ny,nz,rank_info, + Phase,SignDist,vF,vS,GlobalBlobID); + if ( rank==0 ) { printf("Identified %i blobs\n",nblobs); } + + // Create the MeshDataStruct + std::vector meshData(1); + meshData[0].meshName = "domain"; + meshData[0].mesh = std::shared_ptr( new IO::DomainMesh(rank_info,nx,ny,nz,Lx,Ly,Lz) ); + std::shared_ptr PhaseVar( new IO::Variable() ); + std::shared_ptr SignDistVar( new IO::Variable() ); + std::shared_ptr LocalBlobIDVar( new IO::Variable() ); + std::shared_ptr GlobalBlobIDVar( new IO::Variable() ); + PhaseVar->name = "phase"; + PhaseVar->type = IO::VolumeVariable; + PhaseVar->dim = 1; + PhaseVar->data.resize(nx,ny,nz); + meshData[0].vars.push_back(PhaseVar); + SignDistVar->name = "SignDist"; + SignDistVar->type = IO::VolumeVariable; + SignDistVar->dim = 1; + SignDistVar->data.resize(nx,ny,nz); + meshData[0].vars.push_back(SignDistVar); + LocalBlobIDVar->name = "LocalBlobID"; + LocalBlobIDVar->type = IO::VolumeVariable; + LocalBlobIDVar->dim = 1; + LocalBlobIDVar->data.resize(nx,ny,nz); + meshData[0].vars.push_back(LocalBlobIDVar); + GlobalBlobIDVar->name = "GlobalBlobID"; + GlobalBlobIDVar->type = IO::VolumeVariable; + GlobalBlobIDVar->dim = 1; + GlobalBlobIDVar->data.resize(nx,ny,nz); + meshData[0].vars.push_back(GlobalBlobIDVar); + + // Save the results + fillData.copy(Phase,PhaseVar->data); + fillData.copy(SignDist,SignDistVar->data); + fillData.copy(LocalBlobID,LocalBlobIDVar->data); + fillData.copy(GlobalBlobID,GlobalBlobIDVar->data); + IO::writeData( 0, meshData, 2 ); + + + int N_errors = 0; + return N_errors; +} + diff --git a/tests/TestBubble.cpp b/tests/TestBubble.cpp index 32a354c1..65d5c0b6 100644 --- a/tests/TestBubble.cpp +++ b/tests/TestBubble.cpp @@ -5,10 +5,10 @@ #include #include -#include "pmmc.h" -#include "ScaLBL.h" +#include "common/pmmc.h" +#include "common/ScaLBL.h" #include "common/MPI_Helpers.h" -#include "Communication.h" +#include "common/Communication.h" #include "IO/Mesh.h" #include "IO/Writer.h" #include "ProfilerApp.h" diff --git a/tests/TestCommD3Q19.cpp b/tests/TestCommD3Q19.cpp index a5b72215..6bd55cbf 100644 --- a/tests/TestCommD3Q19.cpp +++ b/tests/TestCommD3Q19.cpp @@ -5,7 +5,7 @@ #include #include #include -#include "ScaLBL.h" +#include "common/ScaLBL.h" #include "common/MPI_Helpers.h" using namespace std; diff --git a/tests/TestContactAngle.cpp b/tests/TestContactAngle.cpp index 6fcbf12a..efcf8cf8 100644 --- a/tests/TestContactAngle.cpp +++ b/tests/TestContactAngle.cpp @@ -1,8 +1,8 @@ #include #include -#include "pmmc.h" -//#include "PointList.h" -//#include "Array.h" +#include "common/pmmc.h" +//#include "common/PointList.h" +//#include "common/Array.h" #define RADIUS 15 #define CAPRAD 20 diff --git a/tests/TestCylinderAreas.cpp b/tests/TestCylinderAreas.cpp index c9c56b3c..72478cdc 100644 --- a/tests/TestCylinderAreas.cpp +++ b/tests/TestCylinderAreas.cpp @@ -1,8 +1,8 @@ #include #include -#include "pmmc.h" -//#include "PointList.h" -//#include "Array.h" +#include "common/pmmc.h" +//#include "common/PointList.h" +//#include "common/Array.h" #define RADIUS 15 #define HEIGHT 15.5 diff --git a/tests/TestInterfaceSpeed.cpp b/tests/TestInterfaceSpeed.cpp index f49f176f..9f8e1ada 100644 --- a/tests/TestInterfaceSpeed.cpp +++ b/tests/TestInterfaceSpeed.cpp @@ -1,9 +1,9 @@ #include #include -#include "TwoPhase.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" -#include "Communication.h" +#include "common/Communication.h" #include "IO/Mesh.h" #include "IO/Writer.h" #include "ProfilerApp.h" diff --git a/tests/TestMassConservationD3Q7.cpp b/tests/TestMassConservationD3Q7.cpp index c13d02e7..d32ac90e 100644 --- a/tests/TestMassConservationD3Q7.cpp +++ b/tests/TestMassConservationD3Q7.cpp @@ -7,9 +7,9 @@ #include #include -#include "ScaLBL.h" -#include "Communication.h" -#include "TwoPhase.h" +#include "common/ScaLBL.h" +#include "common/Communication.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" int main(int argc, char **argv) diff --git a/tests/TestSegDist.cpp b/tests/TestSegDist.cpp index 003132fb..4d7d5e92 100644 --- a/tests/TestSegDist.cpp +++ b/tests/TestSegDist.cpp @@ -9,8 +9,8 @@ #include #include #include -#include -#include +#include "common/Array.h" +#include "common/Domain.h" int main(int argc, char **argv) { diff --git a/tests/TestSphereCurvature.cpp b/tests/TestSphereCurvature.cpp index 2113638f..8a9ba151 100644 --- a/tests/TestSphereCurvature.cpp +++ b/tests/TestSphereCurvature.cpp @@ -1,7 +1,7 @@ #include #include -#include "pmmc.h" -#include "Domain.h" +#include "common/pmmc.h" +#include "common/Domain.h" using namespace std; diff --git a/tests/TestTwoPhase.cpp b/tests/TestTwoPhase.cpp index 304277d4..e01b88ae 100644 --- a/tests/TestTwoPhase.cpp +++ b/tests/TestTwoPhase.cpp @@ -7,9 +7,9 @@ #include #include -#include "TwoPhase.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" -#include "Communication.h" +#include "common/Communication.h" #include "IO/Mesh.h" #include "IO/Writer.h" #include "ProfilerApp.h" diff --git a/tests/lb2_Color_wia_mpi.cpp b/tests/lb2_Color_wia_mpi.cpp index 479bc093..a56ed7a0 100644 --- a/tests/lb2_Color_wia_mpi.cpp +++ b/tests/lb2_Color_wia_mpi.cpp @@ -6,9 +6,9 @@ #include #include -#include "ScaLBL.h" -#include "Communication.h" -#include "TwoPhase.h" +#include "common/ScaLBL.h" +#include "common/Communication.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" #ifndef CBUB @@ -1065,7 +1065,7 @@ int main(int argc, char **argv) UnpackID(recvList_YZ, recvCount_YZ ,recvID_YZ, id); //...................................................................................... // Fill in the phase MeshData from neighboring processors - double *sendMeshData_x, *sendMeshData_y, *sendMeshData_z, *sendMeshData_X, *sendMeshData_Y, *sendMeshData_Z; + /*double *sendMeshData_x, *sendMeshData_y, *sendMeshData_z, *sendMeshData_X, *sendMeshData_Y, *sendMeshData_Z; double *sendMeshData_xy, *sendMeshData_yz, *sendMeshData_xz, *sendMeshData_Xy, *sendMeshData_Yz, *sendMeshData_xZ; double *sendMeshData_xY, *sendMeshData_yZ, *sendMeshData_Xz, *sendMeshData_XY, *sendMeshData_YZ, *sendMeshData_XZ; double *recvMeshData_x, *recvMeshData_y, *recvMeshData_z, *recvMeshData_X, *recvMeshData_Y, *recvMeshData_Z; @@ -1109,7 +1109,7 @@ int main(int argc, char **argv) recvMeshData_Xz = new double [recvCount_Xz]; recvMeshData_XY = new double [recvCount_XY]; recvMeshData_YZ = new double [recvCount_YZ]; - recvMeshData_XZ = new double [recvCount_XZ]; + recvMeshData_XZ = new double [recvCount_XZ];*/ if (rank==0) printf ("Devices are ready to communicate. \n"); MPI_Barrier(MPI_COMM_WORLD); diff --git a/tests/lbpm_BlobAnalysis.cpp b/tests/lbpm_BlobAnalysis.cpp index 0afe03f0..fc727634 100644 --- a/tests/lbpm_BlobAnalysis.cpp +++ b/tests/lbpm_BlobAnalysis.cpp @@ -12,8 +12,8 @@ James E. McClure 2015 #include #include -#include "Domain.h" -#include "TwoPhase.h" +#include "common/Domain.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" #include "common/Utilities.h" diff --git a/tests/lbpm_captube_pp.cpp b/tests/lbpm_captube_pp.cpp index aa57c248..9e6bb2e5 100644 --- a/tests/lbpm_captube_pp.cpp +++ b/tests/lbpm_captube_pp.cpp @@ -6,9 +6,9 @@ #include #include -#include "ScaLBL.h" -#include "Communication.h" -#include "TwoPhase.h" +#include "common/ScaLBL.h" +#include "common/Communication.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" int main(int argc, char **argv) diff --git a/tests/lbpm_color_simulator.cpp b/tests/lbpm_color_simulator.cpp index 3bb9808f..ab3ccf54 100644 --- a/tests/lbpm_color_simulator.cpp +++ b/tests/lbpm_color_simulator.cpp @@ -6,9 +6,9 @@ #include #include -#include "ScaLBL.h" -#include "Communication.h" -#include "TwoPhase.h" +#include "common/ScaLBL.h" +#include "common/Communication.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" #include "ProfilerApp.h" diff --git a/tests/lbpm_disc_pp.cpp b/tests/lbpm_disc_pp.cpp index 5de857d2..1e8e72e2 100644 --- a/tests/lbpm_disc_pp.cpp +++ b/tests/lbpm_disc_pp.cpp @@ -6,10 +6,10 @@ #include #include -#include "pmmc.h" -#include "Domain.h" -#include "Communication.h" -#include "MPI_Helpers.h" // This includes mpi.h +#include "common/pmmc.h" +#include "common/Domain.h" +#include "common/Communication.h" +#include "common/MPI_Helpers.h" // This includes mpi.h /* diff --git a/tests/lbpm_permeability_simulator.cpp b/tests/lbpm_permeability_simulator.cpp index 71dfc8b9..4d4ed6aa 100644 --- a/tests/lbpm_permeability_simulator.cpp +++ b/tests/lbpm_permeability_simulator.cpp @@ -6,9 +6,9 @@ #include #include -#include "ScaLBL.h" -#include "Communication.h" -#include "TwoPhase.h" +#include "common/ScaLBL.h" +#include "common/Communication.h" +#include "common/TwoPhase.h" #include "common/MPI_Helpers.h" //#define WRITE_SURFACES diff --git a/tests/lbpm_random_pp.cpp b/tests/lbpm_random_pp.cpp index c485c0df..b6f45357 100644 --- a/tests/lbpm_random_pp.cpp +++ b/tests/lbpm_random_pp.cpp @@ -9,8 +9,8 @@ #include #include #include -#include -#include +#include "common/Array.h" +#include "common/Domain.h" inline void FlipID(char *ID, int N) { diff --git a/tests/lbpm_segmented_decomp.cpp b/tests/lbpm_segmented_decomp.cpp index 432f7d33..c1f2ae1a 100644 --- a/tests/lbpm_segmented_decomp.cpp +++ b/tests/lbpm_segmented_decomp.cpp @@ -10,8 +10,8 @@ #include #include #include -#include -#include +#include "common/Array.h" +#include "common/Domain.h" int main(int argc, char **argv) { diff --git a/tests/lbpm_segmented_pp.cpp b/tests/lbpm_segmented_pp.cpp index 72f52839..8f499157 100644 --- a/tests/lbpm_segmented_pp.cpp +++ b/tests/lbpm_segmented_pp.cpp @@ -9,9 +9,9 @@ #include #include #include -#include -#include -#include +#include "common/Array.h" +#include "common/Domain.h" +#include "common/TwoPhase.h" inline void MeanFilter(DoubleArray &Mesh){ for (int k=1; k<(int)Mesh.size(2)-1; k++){ diff --git a/tests/lbpm_sphere_pp.cpp b/tests/lbpm_sphere_pp.cpp index 75c9a6f5..bfef9b7f 100644 --- a/tests/lbpm_sphere_pp.cpp +++ b/tests/lbpm_sphere_pp.cpp @@ -6,10 +6,10 @@ #include #include -#include "pmmc.h" -#include "Domain.h" +#include "common/pmmc.h" +#include "common/Domain.h" #include "common/MPI_Helpers.h" -#include "Communication.h" +#include "common/Communication.h" /* * Pre-Processor to generate signed distance function from sphere packing diff --git a/tests/pmmc_cylinder.cpp b/tests/pmmc_cylinder.cpp index e3f3a228..b5d120ff 100644 --- a/tests/pmmc_cylinder.cpp +++ b/tests/pmmc_cylinder.cpp @@ -1,8 +1,8 @@ #include #include -#include "pmmc.h" -//#include "PointList.h" -//#include "Array.h" +#include "common/pmmc.h" +//#include "common/PointList.h" +//#include "common/Array.h" #define RADIUS 15 #define HEIGHT 15.5