lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.7.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-06-26 10:23:25 +02:00
parent c02c370437
commit 67ba86d073
1871 changed files with 174422 additions and 131884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmake/Modules/CMakeUninstallTarget.cmake
+2 -6
View File
@@ -8,7 +8,7 @@
#
#
function(WRITE_UNINSTALL_TARGET_SCRIPT)
function(write_uninstall_target_script)
# Create uninstall target template file, if it doesn't exist...
if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in)
set(__uninstall_filename ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake.in)
@@ -42,10 +42,8 @@ endforeach(file)
endif()
endfunction()
# Call the file writing function, if needed
WRITE_UNINSTALL_TARGET_SCRIPT()
write_uninstall_target_script()
# Configure the file that reads the install manifest and processes the files
configure_file(
@@ -56,5 +54,3 @@ configure_file(
# Add the uninstall target
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
cmake/Modules/FindStatTest.cmake
+14 -14
View File
@@ -2,14 +2,14 @@
# - Find StatTest
# This module tries to find the StatTest application
# Once done this will define
#
#
# STATTEST_FOUND - Application found
# STATTEST_APP - Application
# STATTEST_CMD - Command line to run the application
# STATTEST_ADD_TEST - Helper function to define a ctest using
# StatTest (Only if we are using for G4 testing)
#
# Variables used by this module, which can change the default behaviour
# Variables used by this module, which can change the default behaviour
# and need to be set before calling find_package
#
# STATTEST_ROOT_DIR Root directory to StatTest package
@@ -22,7 +22,7 @@ if(NOT GEANT4_ENABLE_TESTING)
endif()
#Search application
#Note that the second suggested path is G4 specific...
#Note that the second suggested path is G4 specific...
find_path(STATTEST_APP_DIR
NAMES StatTestVersion.py
PATHS ${STATTEST_ROOT_DIR} ${CMAKE_SOURCE_DIR}/verification/StatTest
@@ -43,7 +43,7 @@ if(NOT ROOT_FOUND)
set(_root_isok FALSE)
else()
set(_root_isok TRUE)
# - Check if python interpreter is correct version
# - Check if python interpreter is correct version
# (the one compatible with root)
find_package(PythonInterp ${ROOT_PYTHONVER} QUIET)
if(NOT PYTHONINTERP_FOUND)
@@ -70,9 +70,9 @@ if(STATTEST_FOUND)
set(STATTEST_APP ${STATTEST_APP_DIR}/runtests.py)
set(STATTEST_CMD ${PYTHON_EXECUTABLE} ${STATTEST_APP})
# Let's create a function that helps in building tests for
# Let's create a function that helps in building tests for
# regression testing
# function STATTEST_ADD_TEST(<name>
# function STATTEST_ADD_TEST(<name>
# G4TEST testname
# CONFIG conffile
# INPUT inputfile
@@ -82,7 +82,7 @@ if(STATTEST_FOUND)
# [LABELS label1 label2 ...]
# [IMG filename])
function(STATTEST_ADD_TEST stattest)
CMAKE_PARSE_ARGUMENTS(ARG "DEBUG;TEXT"
CMAKE_PARSE_ARGUMENTS(ARG "DEBUG;TEXT"
"CONFIG;INPUT;REFERENCE;G4TEST;IMG"
"LABELS" ${ARGN}
)
@@ -91,12 +91,12 @@ if(STATTEST_FOUND)
if(_len LESS 1)
message(FATAL_ERROR "STATTEST_ADD_TEST: conffile is mandatory")
endif()
list(LENGTH ARG_INPUT _len)
if(_len LESS 1)
message(FATAL_ERROR "STATTEST_ADD_TEST: inputfile is mandatory")
endif()
list(LENGTH ARG_G4TEST _len)
if(_len LESS 1)
message(FATAL_ERROR "STATTEST_ADD_TEST: testname is mandatory")
@@ -108,10 +108,10 @@ if(STATTEST_FOUND)
else()
set(_command ${STATTEST_CMD})
endif()
if(ARG_TEXT)
set(_command ${_command} "-T")
endif()
endif()
#Mandatory parameters
set(_command ${_command} ${ARG_CONFIG} ${ARG_INPUT})
@@ -125,10 +125,10 @@ if(STATTEST_FOUND)
set(_labels "")
endif()
include(Geant4CTest)
include(G4CTest)
#Now build G4 test
GEANT4_ADD_TEST(${stattest}
GEANT4_ADD_TEST(${stattest}
COMMAND ${_command}
DEPENDS ${ARG_G4TEST}
LABELS ${_labels}
cmake/Modules/FindTBB.cmake
+234 -171
View File
@@ -43,13 +43,19 @@
INCLUDE (FindPackageHandleStandardArgs)
IF (CMAKE_VERSION VERSION_GREATER 2.8.7)
SET (_TBB_CHECK_COMPONENTS FALSE)
ELSE (CMAKE_VERSION VERSION_GREATER 2.8.7)
SET (_TBB_CHECK_COMPONENTS TRUE)
ENDIF (CMAKE_VERSION VERSION_GREATER 2.8.7)
#------------------------------------------------------------------------------#
#
# Paths
#
#------------------------------------------------------------------------------#
FIND_PATH (TBB_ROOT_DIR
IF(CMAKE_VERSION VERSION_GREATER 2.8.7)
SET(_TBB_CHECK_COMPONENTS ON)
ELSE()
SET(_TBB_CHECK_COMPONENTS OFF)
ENDIF()
FIND_PATH(TBB_ROOT_DIR
NAMES include/tbb/tbb.h
PATHS ENV TBBROOT
ENV TBB40_INSTALL_DIR
@@ -59,229 +65,286 @@ FIND_PATH (TBB_ROOT_DIR
ENV TBB_ROOT_DIR
DOC "TBB root directory")
FIND_PATH (TBB_INCLUDE_DIR
FIND_PATH(TBB_INCLUDE_DIR
NAMES tbb/tbb.h
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES include
DOC "TBB include directory")
IF (MSVC11)
SET (_TBB_COMPILER vc11)
ELSEIF (MSVC10)
SET (_TBB_COMPILER vc10)
ELSEIF (MSVC90)
SET (_TBB_COMPILER vc9)
ELSEIF (MSVC80)
SET (_TBB_COMPILER vc8)
ELSEIF (WIN32)
SET (_TBB_COMPILER vc_mt)
ENDIF (MSVC11)
#------------------------------------------------------------------------------#
#
# Library suffixes
#
#------------------------------------------------------------------------------#
IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
SET (_TBB_POSSIBLE_LIB_SUFFIXES lib/intel64/${_TBB_COMPILER})
SET (_TBB_POSSIBLE_BIN_SUFFIXES bin/intel64/${_TBB_COMPILER})
ELSE (CMAKE_SIZEOF_VOID_P EQUAL 8)
SET (_TBB_POSSIBLE_LIB_SUFFIXES lib/ia32/${_TBB_COMPILER})
SET (_TBB_POSSIBLE_BIN_SUFFIXES bin/ia32/${_TBB_COMPILER})
ENDIF (CMAKE_SIZEOF_VOID_P EQUAL 8)
IF(MSVC11)
SET(_TBB_COMPILER vc11)
ELSEIF(MSVC10)
SET(_TBB_COMPILER vc10)
ELSEIF(MSVC90)
SET(_TBB_COMPILER vc9)
ELSEIF(MSVC80)
SET(_TBB_COMPILER vc8)
ELSEIF(WIN32)
SET(_TBB_COMPILER vc_mt)
ENDIF(MSVC11)
LIST (APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/$ENV{TBB_ARCH_PLATFORM})
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(_TBB_POSSIBLE_LIB_SUFFIXES lib/intel64/${_TBB_COMPILER})
SET(_TBB_POSSIBLE_BIN_SUFFIXES bin/intel64/${_TBB_COMPILER})
ELSE(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(_TBB_POSSIBLE_LIB_SUFFIXES lib/ia32/${_TBB_COMPILER})
SET(_TBB_POSSIBLE_BIN_SUFFIXES bin/ia32/${_TBB_COMPILER})
ENDIF(CMAKE_SIZEOF_VOID_P EQUAL 8)
FIND_LIBRARY (TBB_LIBRARY_RELEASE
LIST(APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/$ENV{TBB_ARCH_PLATFORM})
IF(UNIX)
FOREACH(_VERSION 4.7 4.4 4.1)
IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
LIST(APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/intel64/gcc${_VERSION})
ELSE()
LIST(APPEND _TBB_POSSIBLE_LIB_SUFFIXES lib/ia32/gcc${_VERSION})
ENDIF()
ENDFOREACH()
ENDIF()
#------------------------------------------------------------------------------#
#
# TBB library
#
#------------------------------------------------------------------------------#
FIND_LIBRARY(TBB_LIBRARY_RELEASE
NAMES tbb
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB release library")
FIND_LIBRARY (TBB_LIBRARY_DEBUG
FIND_LIBRARY(TBB_LIBRARY_DEBUG
NAMES tbb_debug
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB debug library")
IF (TBB_LIBRARY_RELEASE AND TBB_LIBRARY_DEBUG)
IF (NOT TBB_LIBRARY)
SET (TBB_LIBRARY optimized ${TBB_LIBRARY_RELEASE} debug ${TBB_LIBRARY_DEBUG}
CACHE DOC "TBB library" FORCE)
ENDIF (NOT TBB_LIBRARY)
ELSEIF (TBB_LIBRARY_RELEASE)
IF (NOT TBB_LIBRARY)
SET (TBB_LIBRARY ${TBB_LIBRARY_RELEASE} CACHE DOC "TBB library" FORCE)
ENDIF (NOT TBB_LIBRARY)
ENDIF (TBB_LIBRARY_RELEASE AND TBB_LIBRARY_DEBUG)
IF(TBB_LIBRARY_RELEASE AND TBB_LIBRARY_DEBUG)
IF(NOT TBB_LIBRARY)
SET(TBB_LIBRARY optimized ${TBB_LIBRARY_RELEASE} debug ${TBB_LIBRARY_DEBUG}
CACHE DOC "TBB library" FORCE)
ENDIF(NOT TBB_LIBRARY)
LIST(APPEND _TBB_ALL_LIBS optimized ${TBB_LIBRARY_RELEASE} debug ${TBB_LIBRARY_DEBUG})
ELSE()
IF(TBB_LIBRARY_DEBUG)
IF(NOT TBB_LIBRARY)
SET(TBB_LIBRARY ${TBB_LIBRARY_DEBUG} CACHE FILEPATH "TBB library" FORCE)
ENDIF(NOT TBB_LIBRARY)
LIST(APPEND _TBB_ALL_LIBS ${TBB_LIBRARY_DEBUG})
ENDIF(TBB_LIBRARY_DEBUG)
IF (TBB_LIBRARY_DEBUG)
LIST (APPEND _TBB_ALL_LIBS ${TBB_LIBRARY_DEBUG})
ENDIF (TBB_LIBRARY_DEBUG)
IF(TBB_LIBRARY_RELEASE)
IF(NOT TBB_LIBRARY)
SET(TBB_LIBRARY ${TBB_LIBRARY_RELEASE} CACHE FILEPATH "TBB library" FORCE)
ENDIF(NOT TBB_LIBRARY)
LIST(APPEND _TBB_ALL_LIBS ${TBB_LIBRARY_RELEASE})
ENDIF()
ENDIF(TBB_LIBRARY_RELEASE AND TBB_LIBRARY_DEBUG)
IF (TBB_LIBRARY_RELEASE)
LIST (APPEND _TBB_ALL_LIBS ${TBB_LIBRARY_RELEASE})
ENDIF (TBB_LIBRARY_RELEASE)
FOREACH (_TBB_COMPONENT ${TBB_FIND_COMPONENTS})
STRING (TOUPPER ${_TBB_COMPONENT} _TBB_COMPONENT_UPPER)
SET (_TBB_LIBRARY_BASE TBB_${_TBB_COMPONENT_UPPER}_LIBRARY)
#------------------------------------------------------------------------------#
#
# Components
#
#------------------------------------------------------------------------------#
IF (${_TBB_COMPONENT} STREQUAL preview)
SET (_TBB_LIBRARY_NAME tbb_${_TBB_COMPONENT})
ELSE (${_TBB_COMPONENT} STREQUAL preview)
SET (_TBB_LIBRARY_NAME tbb${_TBB_COMPONENT})
message(STATUS " FindTBB.cmake: Trying to find component " ${_TBB_COMPONENT} " using name " ${_TBB_LIBRARY_NAME} " " )
ENDIF (${_TBB_COMPONENT} STREQUAL preview)
SET(_TBB_POSSIBLE_COMPONENTS preview malloc malloc_proxy)
FIND_LIBRARY (${_TBB_LIBRARY_BASE}_RELEASE
NAMES ${_TBB_LIBRARY_NAME}
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB ${_TBB_COMPONENT} release library")
FOREACH(_TBB_COMPONENT ${TBB_FIND_COMPONENTS})
FIND_LIBRARY (${_TBB_LIBRARY_BASE}_DEBUG
NAMES ${_TBB_LIBRARY_NAME}_debug
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB ${_TBB_COMPONENT} debug library")
STRING(REPLACE "_debug" "" _TBB_COMPONENT ${_TBB_COMPONENT})
STRING(TOUPPER ${_TBB_COMPONENT} _TBB_COMPONENT_UPPER)
SET(_TBB_LIBRARY_BASE TBB_${_TBB_COMPONENT_UPPER}_LIBRARY)
MARK_AS_ADVANCED (${_TBB_LIBRARY_BASE} ${_TBB_LIBRARY_BASE}_DEBUG)
IF(${_TBB_COMPONENT} MATCHES "malloc*")
SET(_TBB_LIBRARY_NAME tbb${_TBB_COMPONENT})
ELSE()
SET(_TBB_LIBRARY_NAME tbb_${_TBB_COMPONENT})
ENDIF()
SET (TBB_${_TBB_COMPONENT_UPPER}_FOUND TRUE)
FIND_LIBRARY(${_TBB_LIBRARY_BASE}_RELEASE
NAMES ${_TBB_LIBRARY_NAME}
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB ${_TBB_COMPONENT} release library")
IF (${_TBB_LIBRARY_BASE}_DEBUG AND ${_TBB_LIBRARY_BASE}_RELEASE)
SET (${_TBB_LIBRARY_BASE}
debug ${${_TBB_LIBRARY_BASE}_DEBUG}
optimized ${${_TBB_LIBRARY_BASE}_RELEASE} CACHE DOC
"TBB ${_TBB_COMPONENT} library")
ELSEIF (${_TBB_LIBRARY_BASE}_DEBUG)
SET (${_TBB_LIBRARY_BASE} ${${_TBB_LIBRARY_BASE}_DEBUG})
ELSEIF (${_TBB_LIBRARY_BASE}_RELEASE)
SET (${_TBB_LIBRARY_BASE} ${${_TBB_LIBRARY_BASE}_RELEASE}
CACHE DOC "TBB ${_TBB_COMPONENT} library")
ELSE (${_TBB_LIBRARY_BASE}_DEBUG AND ${_TBB_LIBRARY_BASE}_RELEASE)
# Component missing: record it for a later report
LIST (APPEND _TBB_MISSING_COMPONENTS ${_TBB_COMPONENT})
SET (TBB_${_TBB_COMPONENT_UPPER}_FOUND FALSE)
ENDIF (${_TBB_LIBRARY_BASE}_DEBUG AND ${_TBB_LIBRARY_BASE}_RELEASE)
FIND_LIBRARY(${_TBB_LIBRARY_BASE}_DEBUG
NAMES ${_TBB_LIBRARY_NAME}_debug
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_POSSIBLE_LIB_SUFFIXES}
DOC "TBB ${_TBB_COMPONENT} debug library")
IF (${_TBB_LIBRARY_BASE}_DEBUG)
LIST (APPEND _TBB_ALL_LIBS ${${_TBB_LIBRARY_BASE}_DEBUG})
ENDIF (${_TBB_LIBRARY_BASE}_DEBUG)
MARK_AS_ADVANCED (${_TBB_LIBRARY_BASE} ${_TBB_LIBRARY_BASE}_DEBUG)
IF (${_TBB_LIBRARY_BASE}_RELEASE)
LIST (APPEND _TBB_ALL_LIBS ${${_TBB_LIBRARY_BASE}_RELEASE})
ENDIF (${_TBB_LIBRARY_BASE}_RELEASE)
# default assumption
SET(TBB_${_TBB_COMPONENT_UPPER}_FOUND ON)
SET(TBB_${_TBB_COMPONENT}_FOUND ON)
SET (TBB_${_TBB_COMPONENT}_FOUND ${TBB_${_TBB_COMPONENT_UPPER}_FOUND})
IF(${_TBB_LIBRARY_BASE}_DEBUG AND ${_TBB_LIBRARY_BASE}_RELEASE)
SET(${_TBB_LIBRARY_BASE}
debug ${${_TBB_LIBRARY_BASE}_DEBUG}
optimized ${${_TBB_LIBRARY_BASE}_RELEASE} CACHE STRING
"TBB ${_TBB_COMPONENT} library")
LIST(APPEND _TBB_ALL_LIBS
optimized ${${_TBB_LIBRARY_BASE}_RELEASE}
debug ${${_TBB_LIBRARY_BASE}_DEBUG})
LIST(APPEND TBB_FOUND_COMPONENTS ${_TBB_LIBRARY_BASE} ${_TBB_LIBRARY_BASE}_debug)
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARY ${${_TBB_LIBRARY_BASE}_RELEASE})
ELSEIF(${_TBB_LIBRARY_BASE}_DEBUG)
SET(${_TBB_LIBRARY_BASE} ${${_TBB_LIBRARY_BASE}_DEBUG})
LIST(APPEND _TBB_ALL_LIBS ${${_TBB_LIBRARY_BASE}_DEBUG})
LIST(APPEND TBB_FOUND_COMPONENTS ${_TBB_LIBRARY_BASE})
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARY ${${_TBB_LIBRARY_BASE}_DEBUG})
ELSEIF(${_TBB_LIBRARY_BASE}_RELEASE)
SET(${_TBB_LIBRARY_BASE} ${${_TBB_LIBRARY_BASE}_RELEASE}
CACHE FILEPATH "TBB ${_TBB_COMPONENT} library")
LIST(APPEND _TBB_ALL_LIBS ${${_TBB_LIBRARY_BASE}_RELEASE})
LIST(APPEND TBB_FOUND_COMPONENTS ${_TBB_LIBRARY_BASE}_debug)
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARY ${${_TBB_LIBRARY_BASE}_RELEASE})
ELSE()
# Component missing: record it for a later report
LIST(APPEND _TBB_MISSING_COMPONENTS ${_TBB_COMPONENT})
SET(TBB_${_TBB_COMPONENT}_FOUND OFF)
SET(TBB_${_TBB_COMPONENT_UPPER}_FOUND OFF)
ENDIF()
IF (${_TBB_LIBRARY_BASE})
# setup the TBB_<COMPONENT>_LIBRARIES variable
SET (TBB_${_TBB_COMPONENT_UPPER}_LIBRARIES ${${_TBB_LIBRARY_BASE}})
LIST (APPEND TBB_LIBRARIES ${${_TBB_LIBRARY_BASE}})
ELSE (${_TBB_LIBRARY_BASE})
LIST (APPEND _TBB_MISSING_LIBRARIES ${_TBB_LIBRARY_BASE})
ENDIF (${_TBB_LIBRARY_BASE})
ENDFOREACH (_TBB_COMPONENT ${TBB_FIND_COMPONENTS})
IF(${_TBB_LIBRARY_BASE})
# setup the TBB_<COMPONENT>_LIBRARIES variable
SET(TBB_${_TBB_COMPONENT_UPPER}_LIBRARIES ${${_TBB_LIBRARY_BASE}})
ELSE()
LIST(APPEND _TBB_MISSING_LIBRARIES ${_TBB_LIBRARY_BASE})
ENDIF()
LIST (APPEND TBB_LIBRARIES ${TBB_LIBRARY})
SET (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR})
ENDFOREACH(_TBB_COMPONENT ${TBB_FIND_COMPONENTS})
IF (DEFINED _TBB_MISSING_COMPONENTS AND _TBB_CHECK_COMPONENTS)
IF (NOT TBB_FIND_QUIETLY)
MESSAGE (STATUS "One or more TBB components were not found:")
# Display missing components indented, each on a separate line
FOREACH (_TBB_MISSING_COMPONENT ${_TBB_MISSING_COMPONENTS})
MESSAGE (STATUS " " ${_TBB_MISSING_COMPONENT})
ENDFOREACH (_TBB_MISSING_COMPONENT ${_TBB_MISSING_COMPONENTS})
ENDIF (NOT TBB_FIND_QUIETLY)
ENDIF (DEFINED _TBB_MISSING_COMPONENTS AND _TBB_CHECK_COMPONENTS)
#------------------------------------------------------------------------------#
#
# Standard variables
#
#------------------------------------------------------------------------------#
IF(_TBB_ALL_LIBS)
SET(TBB_LIBRARIES ${_TBB_ALL_LIBS})
ENDIF()
# Determine library's version
IF(TBB_INCLUDE_DIR)
SET(TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR})
ENDIF()
SET (_TBB_VERSION_HEADER ${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h)
IF(DEFINED _TBB_MISSING_COMPONENTS AND _TBB_CHECK_COMPONENTS)
IF(NOT TBB_FIND_QUIETLY)
MESSAGE(STATUS "One or more TBB components were not found:")
# Display missing components indented, each on a separate line
FOREACH(_TBB_MISSING_COMPONENT ${_TBB_MISSING_COMPONENTS})
MESSAGE(STATUS " " ${_TBB_MISSING_COMPONENT})
ENDFOREACH(_TBB_MISSING_COMPONENT ${_TBB_MISSING_COMPONENTS})
ENDIF(NOT TBB_FIND_QUIETLY)
ENDIF(DEFINED _TBB_MISSING_COMPONENTS AND _TBB_CHECK_COMPONENTS)
IF (EXISTS ${_TBB_VERSION_HEADER})
FILE (READ ${_TBB_VERSION_HEADER} _TBB_VERSION_CONTENTS)
#------------------------------------------------------------------------------#
#
# Library's version
#
#------------------------------------------------------------------------------#
STRING (REGEX REPLACE ".*#define TBB_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1"
TBB_VERSION_MAJOR "${_TBB_VERSION_CONTENTS}")
STRING (REGEX REPLACE ".*#define TBB_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
TBB_VERSION_MINOR "${_TBB_VERSION_CONTENTS}")
SET(_TBB_VERSION_HEADER ${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h)
SET (TBB_VERSION ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR})
SET (TBB_VERSION_COMPONENTS 2)
ENDIF (EXISTS ${_TBB_VERSION_HEADER})
IF(EXISTS ${_TBB_VERSION_HEADER})
FILE(READ ${_TBB_VERSION_HEADER} _TBB_VERSION_CONTENTS)
IF (WIN32)
FIND_PROGRAM (LIB_EXECUTABLE NAMES lib
HINTS "$ENV{VS110COMNTOOLS}/../../VC/bin"
"$ENV{VS100COMNTOOLS}/../../VC/bin"
"$ENV{VS90COMNTOOLS}/../../VC/bin"
"$ENV{VS71COMNTOOLS}/../../VC/bin"
"$ENV{VS80COMNTOOLS}/../../VC/bin"
DOC "Library manager")
STRING(REGEX REPLACE ".*#define TBB_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1"
TBB_VERSION_MAJOR "${_TBB_VERSION_CONTENTS}")
STRING(REGEX REPLACE ".*#define TBB_VERSION_MINOR[ \t]+([0-9]+).*" "\\1"
TBB_VERSION_MINOR "${_TBB_VERSION_CONTENTS}")
MARK_AS_ADVANCED (LIB_EXECUTABLE)
ENDIF (WIN32)
SET(TBB_VERSION ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR})
SET(TBB_VERSION_COMPONENTS 2)
ENDIF()
MACRO (GET_LIB_REQUISITES LIB REQUISITES)
IF (LIB_EXECUTABLE)
GET_FILENAME_COMPONENT (_LIB_PATH ${LIB_EXECUTABLE} PATH)
IF(WIN32)
FIND_PROGRAM(LIB_EXECUTABLE NAMES lib
HINTS
"$ENV{VS110COMNTOOLS}/../../VC/bin"
"$ENV{VS100COMNTOOLS}/../../VC/bin"
"$ENV{VS90COMNTOOLS}/../../VC/bin"
"$ENV{VS71COMNTOOLS}/../../VC/bin"
"$ENV{VS80COMNTOOLS}/../../VC/bin"
DOC "Library manager")
IF (MSVC)
MARK_AS_ADVANCED (LIB_EXECUTABLE)
ENDIF()
MACRO(GET_LIB_REQUISITES LIB REQUISITES)
IF(LIB_EXECUTABLE)
GET_FILENAME_COMPONENT(_LIB_PATH ${LIB_EXECUTABLE} PATH)
IF(MSVC)
# Do not redirect the output
UNSET (ENV{VS_UNICODE_OUTPUT})
ENDIF (MSVC)
UNSET(ENV{VS_UNICODE_OUTPUT})
ENDIF()
EXECUTE_PROCESS (COMMAND ${LIB_EXECUTABLE} /nologo /list ${LIB}
EXECUTE_PROCESS(COMMAND ${LIB_EXECUTABLE} /nologo /list ${LIB}
WORKING_DIRECTORY ${_LIB_PATH}/../../Common7/IDE
OUTPUT_VARIABLE _LIB_OUTPUT ERROR_QUIET)
STRING (REPLACE "\n" ";" "${REQUISITES}" "${_LIB_OUTPUT}")
LIST (REMOVE_DUPLICATES ${REQUISITES})
ENDIF (LIB_EXECUTABLE)
ENDMACRO (GET_LIB_REQUISITES)
STRING(REPLACE "\n" ";" "${REQUISITES}" "${_LIB_OUTPUT}")
LIST(REMOVE_DUPLICATES ${REQUISITES})
ENDIF()
ENDMACRO()
IF (_TBB_ALL_LIBS)
# collect lib requisites using the lib tool
FOREACH (_TBB_COMPONENT ${_TBB_ALL_LIBS})
GET_LIB_REQUISITES (${_TBB_COMPONENT} _TBB_REQUISITES)
ENDFOREACH (_TBB_COMPONENT)
ENDIF (_TBB_ALL_LIBS)
IF(_TBB_ALL_LIBS)
# collect lib requisites using the lib tool
FOREACH(_TBB_COMPONENT ${_TBB_ALL_LIBS})
GET_LIB_REQUISITES(${_TBB_COMPONENT} _TBB_REQUISITES)
ENDFOREACH(_TBB_COMPONENT)
ENDIF()
IF (NOT TBB_BINARY_DIR)
SET (_TBB_UPDATE_BINARY_DIR TRUE)
ELSE (NOT TBB_BINARY_DIR)
SET (_TBB_UPDATE_BINARY_DIR FALSE)
ENDIF (NOT TBB_BINARY_DIR)
IF(NOT TBB_BINARY_DIR)
SET(_TBB_UPDATE_BINARY_DIR ON)
ELSE()
SET(_TBB_UPDATE_BINARY_DIR OFF)
ENDIF()
SET (_TBB_BINARY_DIR_HINTS ${_TBB_POSSIBLE_BIN_SUFFIXES})
SET(_TBB_BINARY_DIR_HINTS ${_TBB_POSSIBLE_BIN_SUFFIXES})
IF (_TBB_REQUISITES)
FIND_FILE (TBB_BINARY_DIR NAMES ${_TBB_REQUISITES}
IF(_TBB_REQUISITES)
FIND_FILE(TBB_BINARY_DIR NAMES ${_TBB_REQUISITES}
HINTS ${TBB_ROOT_DIR}
PATH_SUFFIXES ${_TBB_BINARY_DIR_HINTS} NO_DEFAULT_PATH)
ENDIF (_TBB_REQUISITES)
ENDIF()
IF (TBB_BINARY_DIR AND _TBB_UPDATE_BINARY_DIR)
SET (_TBB_BINARY_DIR ${TBB_BINARY_DIR})
UNSET (TBB_BINARY_DIR CACHE)
IF(TBB_BINARY_DIR AND _TBB_UPDATE_BINARY_DIR)
SET(_TBB_BINARY_DIR ${TBB_BINARY_DIR})
UNSET(TBB_BINARY_DIR CACHE)
IF (_TBB_BINARY_DIR)
GET_FILENAME_COMPONENT (TBB_BINARY_DIR ${_TBB_BINARY_DIR} PATH)
ENDIF (_TBB_BINARY_DIR)
ENDIF (TBB_BINARY_DIR AND _TBB_UPDATE_BINARY_DIR)
IF(_TBB_BINARY_DIR)
GET_FILENAME_COMPONENT(TBB_BINARY_DIR ${_TBB_BINARY_DIR} PATH)
ENDIF()
ENDIF()
SET (TBB_BINARY_DIR ${TBB_BINARY_DIR} CACHE PATH "TBB binary directory")
SET(TBB_BINARY_DIR ${TBB_BINARY_DIR} CACHE PATH "TBB binary directory")
MARK_AS_ADVANCED (TBB_INCLUDE_DIR TBB_LIBRARY TBB_LIBRARY_RELEASE
MARK_AS_ADVANCED(TBB_INCLUDE_DIR TBB_LIBRARY TBB_LIBRARY_RELEASE
TBB_LIBRARY_DEBUG TBB_BINARY_DIR)
IF (NOT _TBB_CHECK_COMPONENTS)
SET (_TBB_FPHSA_ADDITIONAL_ARGS HANDLE_COMPONENTS)
ENDIF (NOT _TBB_CHECK_COMPONENTS)
IF(NOT _TBB_CHECK_COMPONENTS)
SET(_TBB_FPHSA_ADDITIONAL_ARGS HANDLE_COMPONENTS)
ENDIF()
IF (CMAKE_VERSION VERSION_GREATER 2.8.2)
LIST (APPEND _TBB_FPHSA_ADDITIONAL_ARGS VERSION_VAR TBB_VERSION)
ENDIF (CMAKE_VERSION VERSION_GREATER 2.8.2)
LIST(APPEND _TBB_FPHSA_ADDITIONAL_ARGS VERSION_VAR TBB_VERSION)
FIND_PACKAGE_HANDLE_STANDARD_ARGS (TBB REQUIRED_VARS TBB_ROOT_DIR
TBB_INCLUDE_DIR TBB_LIBRARY ${_TBB_MISSING_LIBRARIES}
${_TBB_FPHSA_ADDITIONAL_ARGS})
FIND_PACKAGE_HANDLE_STANDARD_ARGS(TBB
REQUIRED_VARS
TBB_ROOT_DIR
TBB_INCLUDE_DIR
TBB_LIBRARY
${_TBB_MISSING_LIBRARIES}
HANDLE_COMPONENTS
${_TBB_FPHSA_ADDITIONAL_ARGS})
cmake/Modules/FindXQuartzGL.cmake
+2 -3
View File
@@ -23,7 +23,7 @@ Result Variables
This module sets the following variables:
``XQuartzGL_FOUND``
True, if the XQuartz GL/GLU libraries were located
True, if the XQuartz GL libraries were located
Cache Variables
^^^^^^^^^^^^^^^
@@ -72,7 +72,6 @@ find_package_handle_standard_args(XQuartzGL
REQUIRED_VARS
XQuartzGL_INCLUDE_DIR
XQuartzGL_gl_LIBRARY
XQuartzGL_glu_LIBRARY
)
mark_as_advanced(XQuartzGL_INCLUDE_DIR XQuartzGL_gl_LIBRARY XQuartzGL_glu_LIBRARY)
@@ -86,7 +85,7 @@ if(XQuartzGL_FOUND)
)
endif()
if(NOT TARGET XQuartzGL::GLU)
if(NOT TARGET XQuartzGL::GLU AND XQuartzGL_glu_LIBRARY)
add_library(XQuartzGL::GLU UNKNOWN IMPORTED)
set_target_properties(XQuartzGL::GLU PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${XQuartzGL_INCLUDE_DIR}"
cmake/Modules/G4BuildSettings.cmake
+1 -5
View File
@@ -6,7 +6,7 @@
# Geant4 libraries and tests,
#
# In addition to the core compiler/linker flags (configured in the
# Geant4MakeRules_<LANG>.cmake files) for Geant4, the build may require
# G4MakeRules_<LANG>.cmake files) for Geant4, the build may require
# further configuration. This module performs this task whicj includes:
#
# 1) Extra build modes for developers
@@ -273,8 +273,6 @@ if(GEANT4_BUILD_MULTITHREADED)
set(GEANT4_MULTITHREADED_CXX_FLAGS "${GEANT4_MULTITHREADED_CXX_FLAGS} ${${GEANT4_BUILD_TLS_MODEL}_TLSMODEL_FLAGS}")
endif()
# Set Defs/Compiler Flags
# TODO: Migrate def to header
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GEANT4_MULTITHREADED_CXX_FLAGS}")
endif()
@@ -424,5 +422,3 @@ foreach(_conftype ${CMAKE_CONFIGURATION_TYPES})
"${BASE_OUTPUT_DIRECTORY}/${_conftype}/${CMAKE_INSTALL_LIBDIR}"
)
endforeach()
cmake/Modules/G4CMakeMain.cmake
+9 -10
View File
@@ -56,19 +56,18 @@ include(G4BuildSettings)
include(G4DeveloperAPI)
# - Provide interface to control use of optional components
include(Geant4OptionalComponents)
include(G4OptionalComponents)
# - Provide interface to control use of UI/Vis components
# Written in a separate module from other optional components because
# there are many complex options to handle.
include(Geant4InterfaceOptions)
include(G4InterfaceOptions)
# - Installation of optional read-only architecture independent data files.
include(Geant4InstallData)
include(G4InstallData)
# - Include testing up front so both source and environments can use it if required
include(Geant4CTest)
include(G4CTest)
#-----------------------------------------------------------------------
# Add the source and environments subdirectories
@@ -95,8 +94,6 @@ endif()
# these tasks can be performed.
#
# - Generate any Use/Config/Support files here once everything else has
# been processed e.g. "UseGeant4.cmake", "Geant4Config.cmake", library
# dependencies etc.
# - Geant4Make.gmk
include(G4ConfigureGNUMakeHelpers)
@@ -110,7 +107,9 @@ include(G4ConfigureCMakeHelpers)
# - Testing configuration.
# Done here, as projects under 'tests' require Geant4Config.
if(GEANT4_ENABLE_TESTING)
add_subdirectory(tests)
if(EXISTS ${PROJECT_SOURCE_DIR}/tests)
add_subdirectory(tests)
endif()
if(EXISTS ${CMAKE_SOURCE_DIR}/benchmarks)
add_subdirectory(benchmarks)
endif()
@@ -137,11 +136,11 @@ endif()
#-----------------------------------------------------------------------
# - CPack-aging
include(Geant4CPackBase)
include(G4CPack)
#-----------------------------------------------------------------------
# Final output - show what's been enabled so that user knows what's
# happening - also useful for later problem solving!
#
GEANT4_PRINT_ENABLED_FEATURES()
geant4_print_enabled_features()
cmake/Modules/Geant4CPackBase.cmake → cmake/Modules/G4CPack.cmake
View File
cmake/Modules/Geant4CTest.cmake → cmake/Modules/G4CTest.cmake
+3 -3
View File
@@ -4,12 +4,12 @@
# Integration and unit tests
# - "ENABLE_TESTING" means all tests under tests/
option(GEANT4_ENABLE_TESTING "Enable and define all the tests of the project" OFF)
GEANT4_ADD_FEATURE(GEANT4_ENABLE_TESTING "Enable and define all the tests of the project")
geant4_add_feature(GEANT4_ENABLE_TESTING "Enable and define all the tests of the project")
mark_as_advanced(GEANT4_ENABLE_TESTING)
# - "BUILD_TESTS" means all 'tests' in individual categories.
option(GEANT4_BUILD_TESTS "Build all the tests of the project" OFF)
GEANT4_ADD_FEATURE(GEANT4_BUILD_TESTS "Build all the tests of the project")
geant4_add_feature(GEANT4_BUILD_TESTS "Build all the tests of the project")
mark_as_advanced(GEANT4_BUILD_TESTS)
#-----------------------------------------------------------------------
@@ -33,7 +33,7 @@ if(GEANT4_ENABLE_TESTING)
endforeach()
# - Add base URL for test reference files
set (GEANT4_TEST_REFERENCES_URL "http://cern.ch/geant4-data/stt/references/" CACHE
set(GEANT4_TEST_REFERENCES_URL "http://cern.ch/geant4-data/stt/references/" CACHE
STRING "base URL for test reference files")
mark_as_advanced(GEANT4_TEST_REFERENCES_URL)
cmake/Modules/G4ClangFormat.cmake
+138 -143
View File
@@ -1,168 +1,163 @@
################################################################################
#.rst
# G4ClangFormat
# =============
#
# Creates a 'format' target that runs clang-format
#
################################################################################
# Functions and helper targets for formatting sources of a target using
# clang-format
# - Include guard
if(NOT __G4CLANGFORMAT_INCLUDED)
set(__G4CLANGFORMAT_INCLUDED 1)
set(__G4CLANGFORMAT_INCLUDED 1)
else()
return()
return()
endif()
#------------------------------------------------------------------------------#
# Default logging directory
set(G4FORMAT_LOGDIR ${PROJECT_BINARY_DIR}/format CACHE PATH
"Output folder of files that are formatted")
#------------------------------------------------------------------------------#
find_program(CLANG_FORMATTER
NAMES
clang-format-8.0
clang-format-7.0
clang-format-6.0
clang-format)
#------------------------------------------------------------------------------#
# Find clang-format (optional)
find_program(CLANG_FORMATTER NAMES
clang-format-6 # prefer clang-format version 6.0
clang-format-6.0
clang-format-mp-6.0 # Apple macports version
clang-format)
function(exclude_from_format)
cmake_parse_arguments(ARG
"" "" "HEADERS;SOURCES;FILES" ${ARGN})
cmake_parse_arguments(ARG "" "" "HEADERS;SOURCES;FILES" ${ARGN})
function(_add_labels _path)
foreach(_FILE ${ARGN})
if(NOT IS_ABSOLUTE ${_FILE})
set(_FILE ${CMAKE_CURRENT_LIST_DIR}${_path}/${_FILE})
endif()
set(_LABELS "EXCLUDE_FORMAT")
get_source_file_property(_EXISTING_LABELS ${_FILE} LABELS)
if(_EXISTING_LABELS)
list(APPEND _LABELS ${_EXISTING_LABELS})
endif()
set_source_files_properties(${_FILE} PROPERTIES
LABELS "${_LABELS}")
get_source_file_property(_EXISTING_LABELS ${_FILE} LABELS)
endforeach()
endfunction()
_add_labels("/include" ${ARG_HEADERS})
_add_labels("/src" ${ARG_SOURCES})
_add_labels("" ${ARG_FILES})
function(_add_labels _path)
foreach(_FILE ${ARGN})
if(NOT IS_ABSOLUTE ${_FILE})
set(_FILE ${CMAKE_CURRENT_LIST_DIR}${_path}/${_FILE})
endif()
set(_LABELS "EXCLUDE_FORMAT")
get_source_file_property(_EXISTING_LABELS ${_FILE} LABELS)
if(_EXISTING_LABELS)
list(APPEND _LABELS ${_EXISTING_LABELS})
endif()
set_source_files_properties(${_FILE} PROPERTIES LABELS "${_LABELS}")
get_source_file_property(_EXISTING_LABELS ${_FILE} LABELS)
endforeach()
endfunction()
_add_labels("/include" ${ARG_HEADERS})
_add_labels("/src" ${ARG_SOURCES})
_add_labels("" ${ARG_FILES})
endfunction()
#------------------------------------------------------------------------------#
function(create_format_directory)
if(NOT EXISTS ${G4FORMAT_LOGDIR})
execute_process(COMMAND ${CMAKE_COMMAND}
-E make_directory ${G4FORMAT_LOGDIR})
endif()
if(NOT EXISTS ${G4FORMAT_LOGDIR})
execute_process(COMMAND ${CMAKE_COMMAND}
-E make_directory ${G4FORMAT_LOGDIR})
endif()
endfunction()
#------------------------------------------------------------------------------#
function(geant4_format_target)
if(CLANG_FORMATTER)
cmake_parse_arguments(G4FMTTARGET
"" "NAME" "SOURCES" ${ARGN})
string(REGEX REPLACE "-format$" "" G4TARGET_NAME "${G4FMTTARGET_NAME}")
# ensure not empty list
if(NOT "${G4FMTTARGET_SOURCES}" STREQUAL "")
# create output directory
create_format_directory()
set(SOURCES ) # list of sources
set(FILELOG ) # string of sources (for log)
foreach(_SOURCE ${G4FMTTARGET_SOURCES})
# files in binary directory are almost always generated files
string(FIND "${_SOURCE}" "${PROJECT_BINARY_DIR}" IN_BINARY_DIR)
# ignore generated files
if(IN_BINARY_DIR GREATER -1)
continue()
endif()
# check if exists (valid full path)
if(EXISTS "${_SOURCE}")
# do nothing -- absolute path was specified
elseif(EXISTS "${CMAKE_CURRENT_LIST_DIR}/${_SOURCE}")
# a relative path was specified
set(_SOURCE ${CMAKE_CURRENT_LIST_DIR}/${_SOURCE})
else()
# neither relative nor absolute
message(STATUS "[format] file not found: '${_SOURCE}'")
continue()
endif()
#string(REPLACE "${PROJECT_SOURCE_DIR}/" "" _SOURCE ${_SOURCE})
get_source_file_property(SOURCE_LABELS ${_SOURCE} LABELS)
list(FIND SOURCE_LABELS "EXCLUDE_FORMAT" EXCLUDE_FORMAT)
if(EXCLUDE_FORMAT GREATER -1)
continue()
endif()
# append to log
set(FILELOG "${FILELOG}${_SOURCE}\n")
# add to list to be processed
list(APPEND SOURCES ${_SOURCE})
endforeach()
# write format file
set(FMTLOG_OUT ${G4FORMAT_LOGDIR}/${G4TARGET_NAME}.txt)
file(WRITE ${FMTLOG_OUT} "${FILELOG}")
file(RELATIVE_PATH FMTLOG_RELATIVE_OUT ${PROJECT_BINARY_DIR} ${FMTLOG_OUT})
# get the number of source files
list(LENGTH SOURCES NUM_SOURCES)
# if there are too many source files (arguments), command will fail
# so process no more than 500 at a time
if(NUM_SOURCES GREATER 500)
# function to generate indices
function(generate_indices VAR NUM)
set(INDICES )
set(N 0)
while(N LESS NUM)
list(APPEND INDICES ${N})
math(EXPR N "${N}+1")
endwhile()
set(${VAR} ${INDICES} PARENT_SCOPE)
endfunction()
# generate 500 indices
generate_indices(INDICES 500)
set(FORMAT_COMMANDS )
# while there are still sources in list
while(NUM_SOURCES GREATER 0)
# if below 500, re-generate indices
if(NUM_SOURCES LESS 500)
generate_indices(INDICES ${NUM_SOURCES})
endif()
# get the subset of first 500
list(GET SOURCES ${INDICES} SOURCES_SUBSET)
# add the target for block of 500
list(APPEND FORMAT_COMMANDS COMMAND ${CLANG_FORMATTER} -i ${SOURCES_SUBSET})
# remove 500 we just processed
list(REMOVE_AT SOURCES ${INDICES})
# update the number of sources remaining
list(LENGTH SOURCES NUM_SOURCES)
endwhile()
# add the custom command
list(LENGTH FORMAT_COMMANDS NUM_COMMANDS)
if(NUM_COMMANDS GREATER 0)
add_custom_target(${G4FMTTARGET_NAME}
${FORMAT_COMMANDS}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT
"Running '${CLANG_FORMATTER}' on source files in '${G4TARGET_NAME}' target (see ${FMTLOG_RELATIVE_OUT})...")
endif()
else()
list(LENGTH SOURCES NUM_SOURCES)
if(NUM_SOURCES GREATER 0)
# if less than 500 source files, add all in one target
add_custom_target(${G4FMTTARGET_NAME}
COMMAND ${CLANG_FORMATTER} -i ${SOURCES}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT
"Running '${CLANG_FORMATTER}' on source files in '${G4TARGET_NAME}' target (see ${FMTLOG_RELATIVE_OUT})...")
endif()
endif(NUM_SOURCES GREATER 500)
endif(NOT "${G4FMTTARGET_SOURCES}" STREQUAL "")
endif(CLANG_FORMATTER)
endfunction()
if(NOT CLANG_FORMATTER)
return()
endif()
#------------------------------------------------------------------------------#
cmake_parse_arguments(G4FMTTARGET "" "NAME" "SOURCES" ${ARGN})
string(REGEX REPLACE "-format$" "" G4TARGET_NAME "${G4FMTTARGET_NAME}")
# ensure not empty list
if("${G4FMTTARGET_SOURCES}" STREQUAL "")
return()
endif()
# create output directory
create_format_directory()
set(SOURCES ) # list of sources
set(FILELOG ) # string of sources (for log)
foreach(_SOURCE ${G4FMTTARGET_SOURCES})
# files in binary directory are almost always generated files
string(FIND "${_SOURCE}" "${PROJECT_BINARY_DIR}" IN_BINARY_DIR)
# ignore generated files
if(IN_BINARY_DIR GREATER -1)
continue()
endif()
# check if exists (valid full path)
if(EXISTS "${_SOURCE}")
# do nothing -- absolute path was specified
elseif(EXISTS "${CMAKE_CURRENT_LIST_DIR}/${_SOURCE}")
# a relative path was specified
set(_SOURCE ${CMAKE_CURRENT_LIST_DIR}/${_SOURCE})
else()
# neither relative nor absolute
message(STATUS "[format] file not found: '${_SOURCE}'")
continue()
endif()
#string(REPLACE "${PROJECT_SOURCE_DIR}/" "" _SOURCE ${_SOURCE})
get_source_file_property(SOURCE_LABELS ${_SOURCE} LABELS)
list(FIND SOURCE_LABELS "EXCLUDE_FORMAT" EXCLUDE_FORMAT)
if(EXCLUDE_FORMAT GREATER -1)
continue()
endif()
# append to log
set(FILELOG "${FILELOG}${_SOURCE}\n")
# add to list to be processed
list(APPEND SOURCES ${_SOURCE})
endforeach()
# write format file
set(FMTLOG_OUT ${G4FORMAT_LOGDIR}/${G4TARGET_NAME}.txt)
file(WRITE ${FMTLOG_OUT} "${FILELOG}")
file(RELATIVE_PATH FMTLOG_RELATIVE_OUT ${PROJECT_BINARY_DIR} ${FMTLOG_OUT})
# get the number of source files
list(LENGTH SOURCES NUM_SOURCES)
# if there are too many source files (arguments), command will fail
# so process no more than 500 at a time
if(NUM_SOURCES GREATER 500)
# function to generate indices
function(generate_indices VAR NUM)
set(INDICES )
set(N 0)
while(N LESS NUM)
list(APPEND INDICES ${N})
math(EXPR N "${N}+1")
endwhile()
set(${VAR} ${INDICES} PARENT_SCOPE)
endfunction()
# generate 500 indices
generate_indices(INDICES 500)
set(FORMAT_COMMANDS )
# while there are still sources in list
while(NUM_SOURCES GREATER 0)
# if below 500, re-generate indices
if(NUM_SOURCES LESS 500)
generate_indices(INDICES ${NUM_SOURCES})
endif()
# get the subset of first 500
list(GET SOURCES ${INDICES} SOURCES_SUBSET)
# add the target for block of 500
list(APPEND FORMAT_COMMANDS COMMAND ${CLANG_FORMATTER} -i ${SOURCES_SUBSET})
# remove 500 we just processed
list(REMOVE_AT SOURCES ${INDICES})
# update the number of sources remaining
list(LENGTH SOURCES NUM_SOURCES)
endwhile()
# add the custom command
list(LENGTH FORMAT_COMMANDS NUM_COMMANDS)
if(NUM_COMMANDS GREATER 0)
add_custom_target(${G4FMTTARGET_NAME}
${FORMAT_COMMANDS}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT "Running '${CLANG_FORMATTER}' on source files in '${G4TARGET_NAME}' target (see ${FMTLOG_RELATIVE_OUT})...")
endif()
else()
list(LENGTH SOURCES NUM_SOURCES)
if(NUM_SOURCES GREATER 0)
# if less than 500 source files, add all in one target
add_custom_target(${G4FMTTARGET_NAME}
COMMAND ${CLANG_FORMATTER} -i ${SOURCES}
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
COMMENT
"Running '${CLANG_FORMATTER}' on source files in '${G4TARGET_NAME}' target (see ${FMTLOG_RELATIVE_OUT})...")
endif()
endif(NUM_SOURCES GREATER 500)
endfunction()
cmake/Modules/G4ConfigureCMakeHelpers.cmake
+13 -4
View File
@@ -63,7 +63,7 @@ set(GEANT4_THIRD_PARTY_IMPORT_SETUP )
# Externals libraries that may be present
set(GEANT4_EXTERNALS_TARGETS )
# - Stuff from Geant4OptionalComponents.cmake
# - Stuff from G4OptionalComponents.cmake
# - CLHEP
# If it's internal, add it to the externals list
if(NOT GEANT4_USE_SYSTEM_CLHEP)
@@ -82,13 +82,20 @@ if(NOT GEANT4_USE_SYSTEM_ZLIB)
list(APPEND GEANT4_EXTERNALS_TARGETS G4zlib)
endif()
# - PTL
# If it's internal, add it to the externals list
if(NOT GEANT4_USE_SYSTEM_PTL)
list(APPEND GEANT4_EXTERNALS_TARGETS G4ptl)
set(PTL_BUILDTREE_PREFIX "${PROJECT_BINARY_DIR}/source/externals/ptl")
set(PTL_INSTALLTREE_PREFIX "\${_geant4_thisdir}/../PTL")
endif()
# - USolids
# Compile definitions
if(GEANT4_USE_USOLIDS OR GEANT4_USE_PARTIAL_USOLIDS)
set(GEANT4_USE_USOLIDS_EITHER ON)
endif()
# - Stuff from Geant4InterfaceOptions.cmake
#-----------------------------------------------------------------------
# - Common Build/Install Tree Configuration files
@@ -124,7 +131,8 @@ set(GEANT4_INCLUDE_DIR_SETUP "
# Geant4 configured for use from the build tree - absolute paths are used.
set(Geant4_INCLUDE_DIR \"${__geant4_buildtree_include_dirs}\")
")
# Builtin PTL is self located
set(PACKAGE_PTL_PREFIX "${PTL_BUILDTREE_PREFIX}")
# Geant4 data used in build tree
geant4_export_datasets(BUILD GEANT4_DATASET_DESCRIPTIONS)
@@ -238,7 +246,8 @@ else()
get_filename_component(Geant4_INCLUDE_DIR \"\${_geant4_thisdir}/${GEANT4_RELATIVE_HEADER_PATH}\" ABSOLUTE)
")
endif()
# Builtin PTL is self located
set(PACKAGE_PTL_PREFIX "${PTL_INSTALLTREE_PREFIX}")
# Geant4 data used in install tree
geant4_export_datasets(INSTALL GEANT4_DATASET_DESCRIPTIONS)
cmake/Modules/G4ConfigureGNUMakeHelpers.cmake
+7
View File
@@ -507,6 +507,13 @@ macro(_g4tc_configure_tc_variables SHELL_FAMILY SCRIPT_NAME)
_g4tc_setenv_command(GEANT4_TC_G4LIB_USE_ZLIB ${SHELL_FAMILY} G4LIB_USE_ZLIB 1)
endif()
# - PTL...
if(GEANT4_USE_SYSTEM_PTL)
set(GEANT4_TC_G4LIB_USE_PTL "# USING SYSTEM PTL")
else()
_g4tc_setenv_command(GEANT4_TC_G4LIB_USE_PTL ${SHELL_FAMILY} G4LIB_USE_PTL 1)
endif()
# - GDML...
if(GEANT4_USE_GDML)
_g4tc_setenv_command(GEANT4_TC_G4LIB_USE_GDML ${SHELL_FAMILY} G4LIB_USE_GDML 1)
cmake/Modules/G4ConfigurePkgConfigHelpers.cmake
+20 -9
View File
@@ -167,12 +167,21 @@ if(NOT GEANT4_BUILD_GRANULAR_LIBS AND UNIX)
set(G4_BUILTWITH_ZLIB "yes")
endif()
# - PTL
if(GEANT4_USE_SYSTEM_PTL)
set(G4_BUILTWITH_PTL "no")
else()
set(G4_BUILTWITH_PTL "yes")
endif()
# - GDML
if(GEANT4_USE_GDML)
set(G4_BUILTWITH_GDML "yes")
set(G4_XERCESC_INCLUDE_DIRS ${XercesC_INCLUDE_DIR})
list(REMOVE_DUPLICATES G4_XERCESC_INCLUDE_DIRS)
list(REMOVE_ITEM G4_XERCESC_INCLUDE_DIRS ${_cxx_compiler_dirs})
if(_cxx_compiler_dirs)
list(REMOVE_ITEM G4_XERCESC_INCLUDE_DIRS ${_cxx_compiler_dirs})
endif()
set(G4_XERCESC_CFLAGS )
foreach(_dir ${G4_XERCESC_INCLUDE_DIRS})
@@ -194,7 +203,9 @@ if(NOT GEANT4_BUILD_GRANULAR_LIBS AND UNIX)
set(G4_BUILTWITH_USOLIDS "yes")
set(G4_USOLIDS_INCLUDE_DIRS "${USOLIDS_INCLUDE_DIRS} ${VECGEOM_EXTERNAL_INCLUDES}")
list(REMOVE_DUPLICATES G4_USOLIDS_INCLUDE_DIRS)
list(REMOVE_ITEM G4_USOLIDS_INCLUDE_DIRS ${_cxx_compiler_dirs})
if(_cxx_compiler_dirs)
list(REMOVE_ITEM G4_USOLIDS_INCLUDE_DIRS ${_cxx_compiler_dirs})
endif()
string(REPLACE ";" " " G4_USOLIDS_CFLAGS "${VECGEOM_DEFINITIONS}")
foreach(_dir ${G4_USOLIDS_INCLUDE_DIRS})
@@ -221,14 +232,12 @@ if(NOT GEANT4_BUILD_GRANULAR_LIBS AND UNIX)
# - Qt
if(GEANT4_USE_QT)
set(G4_BUILTWITH_QT "yes")
if(QT4_FOUND)
set(G4_QT_INCLUDE_DIRS ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} ${QT_QTOPENGL_INCLUDE_DIR})
else()
set(G4_QT_INCLUDE_DIRS ${Qt5Core_INCLUDE_DIRS} ${Qt5Gui_INCLUDE_DIRS} ${Qt5Widgets_INCLUDE_DIRS} ${Qt5OpenGL_INCLUDE_DIRS} ${Qt5PrintSupport_INCLUDE_DIRS})
endif()
set(G4_QT_INCLUDE_DIRS ${Qt5Core_INCLUDE_DIRS} ${Qt5Gui_INCLUDE_DIRS} ${Qt5Widgets_INCLUDE_DIRS} ${Qt5OpenGL_INCLUDE_DIRS} ${Qt5PrintSupport_INCLUDE_DIRS})
list(REMOVE_DUPLICATES G4_QT_INCLUDE_DIRS)
list(REMOVE_ITEM G4_QT_INCLUDE_DIRS ${_cxx_compiler_dirs})
if(_cxx_compiler_dirs)
list(REMOVE_ITEM G4_QT_INCLUDE_DIRS ${_cxx_compiler_dirs})
endif()
set(G4_QT_CFLAGS )
foreach(_dir ${G4_QT_INCLUDE_DIRS})
@@ -289,7 +298,9 @@ if(NOT GEANT4_BUILD_GRANULAR_LIBS AND UNIX)
if(G4_CONFIG_NEEDS_X11)
set(_raw_x11_includes ${X11_INCLUDE_DIR})
list(REMOVE_DUPLICATES _raw_x11_includes)
list(REMOVE_ITEM _raw_x11_includes ${_cxx_compiler_dirs})
if(_cxx_compiler_dirs)
list(REMOVE_ITEM _raw_x11_includes ${_cxx_compiler_dirs})
endif()
set(G4_X11_CFLAGS )
foreach(_p ${_raw_x11_includes})
set(G4_X11_CFLAGS "-I${_p} ${G4_X11_CFLAGS}")
cmake/Modules/Geant4DatasetDefinitions.cmake → cmake/Modules/G4DatasetDefinitions.cmake
+2 -2
View File
@@ -18,11 +18,11 @@ geant4_add_dataset(
# - Low energy electromagnetics
geant4_add_dataset(
NAME G4EMLOW
VERSION 7.9.1
VERSION 7.12
FILENAME G4EMLOW
EXTENSION tar.gz
ENVVAR G4LEDATA
MD5SUM 1308dc5d73b5539557e2ec6b96f7e5ef
MD5SUM 0d3d46eeb7420f2b996242fec756ee52
)
# - Photon evaporation
cmake/Modules/G4DeveloperAPI.cmake
+962 -4
View File
@@ -9,9 +9,6 @@
# CMake functions and macros for declaring and working with build
# products of Geant4.
#
# WIP: At present, this simply forwards to the old implementation
# Eventually will allow switch between the old and the new,
# then just the new once transition complete.
#-----------------------------------------------------------------
# License and Disclaimer
@@ -44,4 +41,965 @@ else()
return()
endif()
include(G4DeveloperAPI_OLD)
# Whilst we test, allow switching between old and new implementations
option(GEANT4_USE_NEW_CMAKE "Use new CMake module/library implementation" ON)
mark_as_advanced(GEANT4_USE_NEW_CMAKE)
if(NOT GEANT4_USE_NEW_CMAKE)
include(G4DeveloperAPI_OLD)
return()
endif()
# Needed modules
include(G4ClangFormat)
#-----------------------------------------------------------------------
#.rst:
# Module Commands
# ^^^^^^^^^^^^^^^
#
# .. cmake:command:: geant4_add_module
#
# .. code-block:: cmake
#
# geant4_add_module(<name>
# PUBLIC_HEADERS header1 [header2 ...]
# [SOURCES source1 [source2 ...]])
#
# Add a Geant4 module called ``<name>`` to the project, composed
# of the source files listed in the ``PUBLIC_HEADERS`` and ``SOURCES``
# arguments. The ``<name>`` must be unique within the project.
# The directory in which the module is added (i.e. ``CMAKE_CURRENT_LIST_DIR``
# for the CMake script in which ``geant4_add_module`` is called) must contain:
#
# * An ``include`` subdirectory for the public headers
# * A ``src`` subdirectory for source files if the module provides these
#
# The ``PUBLIC_HEADERS`` argument must list the headers comprising the
# public interface of the module. If a header is supplied as a relative path,
# this is interpreted as being relative to the ``include`` subdirectory of the module.
# Absolute paths may also be supplied, e.g. if headers are generated by the project.
#
# The ``SOURCES`` argument should list any source files for the module.
# If a source is is supplied as a relative path, this is interpreted as being
# relative to the ``src`` subdirectory of the module. Absolute paths may
# also be supplied, e.g. if sources are generated by the project.
#
function(geant4_add_module _name)
__geant4_module_assert_not_exists(${_name})
set_property(GLOBAL APPEND PROPERTY GEANT4_DEFINED_MODULES ${_name})
cmake_parse_arguments(G4ADDMOD
""
""
"PUBLIC_HEADERS;SOURCES"
${ARGN}
)
# - Check required directory structure at definition point
# Headers always
if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/include")
message(FATAL_ERROR "Missing required 'include' subdirectory for module '${_name}' at '${CMAKE_CURRENT_LIST_DIR}'")
endif()
# Sources if defined
if(G4ADDMOD_SOURCES AND (NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/src"))
message(FATAL_ERROR "Missing required 'src' subdirectory for module '${_name}' at '${CMAKE_CURRENT_LIST_DIR}'")
endif()
# Compose header/source lists
set(__tmp_HEADERS)
foreach(__elem ${G4ADDMOD_PUBLIC_HEADERS})
if(IS_ABSOLUTE "${__elem}")
list(APPEND __tmp_HEADERS "${__elem}")
else()
list(APPEND __tmp_HEADERS "${CMAKE_CURRENT_LIST_DIR}/include/${__elem}")
endif()
endforeach()
geant4_set_module_property(${_name} PROPERTY PUBLIC_HEADERS ${__tmp_HEADERS})
set(__tmp_SOURCES)
foreach(__elem ${G4ADDMOD_SOURCES})
if(IS_ABSOLUTE "${__elem}")
list(APPEND __tmp_SOURCES "${__elem}")
else()
list(APPEND __tmp_SOURCES "${CMAKE_CURRENT_LIST_DIR}/src/${__elem}")
endif()
endforeach()
geant4_set_module_property(${_name} PROPERTY SOURCES ${__tmp_SOURCES})
# Set the default include directory for this module
geant4_module_include_directories(${_name} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>)
# Backward compatibility shim for direct usage of build directory
# Not all clients (esp. those using ROOT) may not fully support usage requirements
# and expect GEANT4_INCLUDE_DIRS to be complete
set_property(GLOBAL APPEND PROPERTY GEANT4_BUILDTREE_INCLUDE_DIRS "${CMAKE_CURRENT_LIST_DIR}/include")
# Record where we're defined so we can pop the file into IDEs
geant4_set_module_property(${_name} PROPERTY CMAKE_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}")
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_module_include_directories
#
# .. code-block:: cmake
#
# geant4_module_include_directories(<module>
# [PUBLIC pub1 [pub2 ...]
# [PRIVATE pri1 [pri2 ...]
# [INTERFACE int1 [int2 ...])
#
# Add include directories to given module.
#
function(geant4_module_include_directories _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4MODINCDIR
""
""
"PUBLIC;PRIVATE;INTERFACE"
${ARGN}
)
foreach(_dir ${G4MODINCDIR_PUBLIC})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${_dir})
geant4_set_module_property(${_module} APPEND PROPERTY INCLUDE_DIRECTORIES ${_dir})
endforeach()
foreach(_dir ${G4MODINCDIR_PRIVATE})
geant4_set_module_property(${_module} APPEND PROPERTY INCLUDE_DIRECTORIES ${_dir})
endforeach()
foreach(_dir ${G4MODINCDIR_INTERFACE})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${_dir})
endforeach()
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_module_link_libraries
#
# .. code-block:: cmake
#
# geant4_module_link_libraries(<module>
# [PUBLIC pub1 [pub2 ...]
# [PRIVATE pri1 [pri2 ...]
# [INTERFACE int1 [int2 ...])
#
# Link ``<module>`` to given targets.
#
function(geant4_module_link_libraries _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4MODLINKLIB
""
""
"PUBLIC;PRIVATE;INTERFACE"
${ARGN}
)
foreach(_lib ${G4MODLINKLIB_PUBLIC})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${_lib})
geant4_set_module_property(${_module} APPEND PROPERTY LINK_LIBRARIES ${_lib})
endforeach()
foreach(_lib ${G4MODLINKLIB_PRIVATE})
geant4_set_module_property(${_module} APPEND PROPERTY LINK_LIBRARIES ${_lib})
endforeach()
foreach(_dir ${G4MODLINKLIB_INTERFACE})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${_lib})
endforeach()
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_module_compile_definitions
#
# .. code-block:: cmake
#
# geant4_module_compile_definitions(<module>
# [PUBLIC pub1 [pub2 ...]
# [PRIVATE pri1 [pri2 ...]
# [INTERFACE int1 [int2 ...])
#
# Add compile definitions for this module
#
# Use cases:
# 1. workarounds when a config header isn't suitable
#
# Needs care with DLLs if used for import/export declspecs
# Application of specific defs to single files not considered
# Expected that uses cases here minimal, and developers should
# in that case use set_source_files_properties or similar
# directly.
#
function(geant4_module_compile_definitions _module)
__geant4_module_assert_exists(${_module})
cmake_parse_arguments(G4MODCOMPILEDEF
""
""
"PUBLIC;PRIVATE;INTERFACE"
${ARGN}
)
foreach(_lib ${G4MODCOMPILEDEF_PUBLIC})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS ${_lib})
geant4_set_module_property(${_module} APPEND PROPERTY COMPILE_DEFINITIONS ${_lib})
endforeach()
foreach(_lib ${G4MODCOMPILEDEF_PRIVATE})
geant4_set_module_property(${_module} APPEND PROPERTY COMPILE_DEFINITIONS ${_lib})
endforeach()
foreach(_dir ${G4MODCOMPILEDEF_INTERFACE})
geant4_set_module_property(${_module} APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS ${_lib})
endforeach()
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_get_modules
#
# .. code-block:: cmake
#
# geant4_get_modules(<result>)
#
# Store the list of currently defined modules in the variable ``<result>``.
#
function(geant4_get_modules _result)
get_property(__tmp GLOBAL PROPERTY GEANT4_DEFINED_MODULES)
set(${_result} ${__tmp} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_has_module
#
# .. code-block:: cmake
#
# geant4_has_module(<result> <name>)
#
# Set variable ``<result>`` to a boolean which will be true if the module
# ``<name>`` is defined.
#
function(geant4_has_module _result _name)
set(__exists FALSE)
geant4_get_modules(__tmp)
if(__tmp)
list(FIND __tmp ${_name} __index)
if(__index GREATER -1)
set(__exists TRUE)
endif()
endif()
set(${_result} ${__exists} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# Module Properties
# =================
#
# A Geant4 module stores its build and usage requirements in a series
# of properties:
#
# * ``PUBLIC_HEADERS``
# * ``PRIVATE_HEADERS``
# * ``SOURCES``
# * ``INTERFACE_COMPILE_DEFINITIONS``
# * ``COMPILE_DEFINITIONS``
# * ``INTERFACE_INCLUDE_DIRECTORIES``
# * ``INCLUDE_DIRECTORIES``
# * ``INTERFACE_LINK_LIBRARIES``
# * ``LINK_LIBRARIES``
# * ``PARENT_TARGET``
# * ``CMAKE_LIST_FILE``
# * ``GLOBAL_DEPENDENCIES``
#
# The properties of a module may be queried and set using the following
# commands.
# .. cmake:command:: geant4_get_module_property
#
# .. code-block:: cmake
#
# geant4_get_module_property(<result> <module> <property>)
#
# Store value of property ``<property>`` for ``<module>`` in variable
# ``<result>``.
#
# If ``<property>`` is not a valid module property, a FATAL_ERROR is
# emitted.
#
function(geant4_get_module_property _output _module _propertyname)
__geant4_module_assert_exists(${_module})
__geant4_module_validate_property(${_propertyname})
get_property(__result GLOBAL PROPERTY ${_module}_${_propertyname})
set(${_output} ${__result} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_set_module_property
#
# .. code-block:: cmake
#
# geant4_set_module_property(<module>
# [APPEND | APPEND_STRING]
# PROPERTY <property> <value>)
#
# Set property ``<property>`` of module ``<module>`` to ``<value>``.
#
# If ``APPEND`` is supplied, ``<value>`` will be appended to any existing
# value for the property as a list.
#
# If ``APPEND_STRING`` is supplied, ``<value>`` will be appended to any existing
# value for the property as a string. This option is mutually exclusive with
# ``APPEND``.
#
# If ``<property>`` is not a valid module property, a FATAL_ERROR is
# emitted.
#
function(geant4_set_module_property _module)
cmake_parse_arguments(G4SMP
"APPEND;APPEND_STRING"
""
"PROPERTY"
${ARGN}
)
# module must exist!
__geant4_module_assert_exists(${_module})
# Append/Append_string are mutually exclusive
if(G4SMP_APPEND AND G4SMP_APPEND_STRING)
message(FATAL_ERROR "geant4_set_module_property: cannot set both APPEND and APPEND_STRING")
elseif(G4SMP_APPEND)
set(G4SMP_APPEND_MODE "APPEND")
elseif(G4SMP_APPEND_MODE)
set(G4SMP_APPEND_MODE "APPEND_STRING")
endif()
# First element of PROPERTY list is prop name
list(GET G4SMP_PROPERTY 0 G4SMP_PROPERTY_NAME)
if(NOT G4SMP_PROPERTY_NAME)
message(FATAL_ERROR "geant4_set_module_property: Required PROPERTY argument is missing")
endif()
__geant4_module_validate_property(${G4SMP_PROPERTY_NAME})
# Remainder is arguments, so strip first element
list(REMOVE_AT G4SMP_PROPERTY 0)
set_property(GLOBAL ${G4SMP_APPEND_MODE} PROPERTY ${_module}_${G4SMP_PROPERTY_NAME} ${G4SMP_PROPERTY})
endfunction()
#-----------------------------------------------------------------------
#.rst:
# Category Commands
# ^^^^^^^^^^^^^^^^^
#
# .. cmake:command:: geant4_add_category
#
# .. code-block:: cmake
#
# geant4_add_category(<name> MODULES <module> [<module> ...])
#
# Add a Geant4 category ``<name>`` to the project, composed of the modules
# supplied in the ``MODULES`` list.
#
# Calling this function does not create an actual CMake library target.
# Because modules declare dependencies on modules rather than libraries, we
# defer creation of library targets to after creation of categories, which
# allows resolution of module <-> category use. Additionally, category specific
# actions such as install may be added.
#
function(geant4_add_category _name)
# Check existence? final add_library will warn, but may wish to double check
set_property(GLOBAL APPEND PROPERTY GEANT4_DEFINED_CATEGORIES ${_name})
cmake_parse_arguments(G4ADDCAT
""
""
"MODULES"
${ARGN}
)
# - Modules must not be empty (Could also just be ARGN)
if(NOT G4ADDCAT_MODULES)
message(FATAL_ERROR "geant4_add_category: Missing/empty 'MODULES' argument")
endif()
# Compose Category from Modules
foreach(__g4module ${G4ADDCAT_MODULES})
# Module must not have been composed already
geant4_get_module_property(_parent ${__g4module} PARENT_TARGET)
if(${_parent})
message(FATAL_ERROR "geant4_add_category: trying to compose category '${_name}' using module '${__g4module}' which is already composed into category '${_parent}'")
endif()
# Compose it
geant4_set_module_property(${__g4module} PROPERTY PARENT_TARGET ${_name})
set_property(GLOBAL APPEND PROPERTY GEANT4_CATEGORIES_${_name}_MODULES ${__g4module})
geant4_get_module_property(_headers ${__g4module} PUBLIC_HEADERS)
set_property(GLOBAL APPEND PROPERTY GEANT4_CATEGORIES_${_name}_PUBLIC_HEADERS ${_headers})
endforeach()
# As we do not create a physical target, store the script in which we're called
set_property(GLOBAL PROPERTY GEANT4_CATEGORIES_${_name}_CMAKE_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}")
endfunction()
#-----------------------------------------------------------------------
# Resolve a list of links
# These may include Geant4 modules as well as standard targets or other expressions
# Resolve Modules to PARENT_TARGET, removing duplicates
# Leave other links unchanged
function(geant4_resolve_link_libraries _list)
set(_resolved_list )
foreach(__lib ${${_list}})
# If "library" is a module, resolve it to PARENT_TARGET
geant4_has_module(__is_module ${__lib})
if(__is_module)
geant4_get_module_property(__parent_lib ${__lib} PARENT_TARGET)
list(APPEND _resolved_list ${__parent_lib})
else()
list(APPEND _resolved_list ${__lib})
endif()
endforeach()
if(_resolved_list)
list(REMOVE_DUPLICATES _resolved_list)
endif()
set(${_list} ${_resolved_list} PARENT_SCOPE)
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_compose_targets
#
# .. code-block:: cmake
#
# geant4_compose_targets()
#
# Create physical SHARED/STATIC library targets from the defined Geant4
# categories and modules.
#
# Can only be called once, and must be done so after all Geant4 libraries
# and modules are defined.
#
function(geant4_compose_targets)
get_property(__alreadyCalled GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_CALLED)
if(__alreadyCalled)
get_property(__callsite GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_LIST_FILE)
message(FATAL_ERROR "geant4_compose_targets already called from ${__callsite}")
endif()
# Check that every defined module is composed
geant4_get_modules(__g4definedmodules)
foreach(__module ${__g4definedmodules})
geant4_get_module_property(__iscomposed ${__module} PARENT_TARGET)
if(NOT __iscomposed)
message(FATAL_ERROR "Geant4 module '${__module}' is not composed into any category")
endif()
endforeach()
# Process all defined libraries, except for G4clhep{-static}
# G4clhep/G4ptl are a corner cases because its call to add_library happens
# at a different (lower) directory level than all the other targets
# This means we cannot install it here. That's left to it
get_property(__g4definedlibraries GLOBAL PROPERTY GEANT4_DEFINED_CATEGORIES)
list(REMOVE_ITEM __g4definedlibraries G4clhep G4clhep-static G4ptl G4ptl-static)
set(__g4builtlibraries)
set(__g4public_headers)
foreach(__g4lib ${__g4definedlibraries})
if(BUILD_SHARED_LIBS)
__geant4_add_library(${__g4lib} SHARED)
list(APPEND __g4builtlibraries ${__g4lib})
endif()
if(BUILD_STATIC_LIBS)
__geant4_add_library(${__g4lib} STATIC)
list(APPEND __g4builtlibraries ${__g4lib}-static)
endif()
get_property(__headers GLOBAL PROPERTY GEANT4_CATEGORIES_${__g4lib}_PUBLIC_HEADERS)
list(APPEND __g4public_headers ${__headers})
endforeach()
#-----------------------------------------------------------------------
# TEMP INSTALL - do here purely to review exported links. Should be
# factored out into separate function later.
install(TARGETS ${__g4builtlibraries}
EXPORT Geant4LibraryDepends
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT Development
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT Runtime
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT Runtime
INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}")
install(FILES ${__g4public_headers} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}" COMPONENT Development)
set_property(GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_CALLED ON)
set_property(GLOBAL PROPERTY GEANT4_COMPOSE_TARGETS_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}")
endfunction()
#-----------------------------------------------------------------------
#.rst:
# Backward Compatibility Commands
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# These commands implement the old module/library definition macros in
# terms of the new command set. They provide a facade allowing migration
# to the new interfaces with a controlled transition.
#
# As migration progresses, these commands will gradually be deprecated,
# with warnings issued about what to do at each stage.
#
# .. cmake:command:: geant4_define_module
#
# .. code-block:: cmake
#
# geant4_define_module(NAME <name>
# HEADERS header1 [header2 ...]
# SOURCES source1 [source2 ...]
# GRANULAR_DEPENDENCIES lib1 [lib2 ...]
# GLOBAL_DEPENDENCIES lib1 [lib2 ...]
# LINK_LIBRARIES lib1 [lib2 ...])
#
# DEPRECATED: Use :cmake:command:`geant4_add_module` to add a module with headers/sources,
# and :cmake:command:`geant4_module_link_libraries` to declare internal and external
# libraries to link to.
#
function(geant4_define_module)
cmake_parse_arguments(G4DEFMOD
""
"NAME"
"HEADERS;SOURCES;GRANULAR_DEPENDENCIES;GLOBAL_DEPENDENCIES;LINK_LIBRARIES;HEADERS_EXCLUDE_FORMAT;SOURCES_EXCLUDE_FORMAT"
${ARGN}
)
# HEADERS -> PUBLIC_HEADERS
# SOURCES -> SOURCES
# Don't support clang-formatting yet.
geant4_add_module(${G4DEFMOD_NAME}
PUBLIC_HEADERS ${G4DEFMOD_HEADERS}
SOURCES ${G4DEFMOD_SOURCES}
)
# GRANULAR_DEPENDENCIES -> geant4_module_link_libraries(mod PUBLIC ...)
# GLOBAL_DEPENDENCIES -> new property... Just record it for now, later
# we need to link these to the physical library the module is composed into
# checking that
# i) Granular -> Global link is complete, i.e. resolving granular deps results
# in same global link list.
# Has to be stored separately because we want/need to check for full resolution of
# the granular libs to the same set of global libs. That's needed to ensure we
# can correct any missing links in existing GRANULAR_DEPENDENCIES lists.
# (i.e. it's a transtional property)
# LINK_LIBRARIES -> geant4_module_link_libraries(mod PUBLIC ...)
geant4_module_link_libraries(${G4DEFMOD_NAME} PUBLIC ${G4DEFMOD_GRANULAR_DEPENDENCIES} ${G4DEFMOD_LINK_LIBRARIES})
geant4_set_module_property(${G4DEFMOD_NAME} PROPERTY GLOBAL_DEPENDENCIES ${G4DEFMOD_GLOBAL_DEPENDENCIES})
# When we are ready, start issuing a deprecation warning here, including instructions for
# migration...
# message(WARNING "Use of geant4_define_module is deprecated, please use... instead")
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_global_library_target
#
# .. code-block:: cmake
#
# geant4_global_library_target(NAME <name>
# COMPONENTS file1 [file2 ...])
#
# DEPRECATED: Use :cmake:command:`geant4_add_library` to add a library with a list
# of modules.
#
# This function provides a facade around :cmake:command:`geant4_add_library` to
# allow back compatibility with the older module/library functions
#
function(geant4_global_library_target)
cmake_parse_arguments(G4GLOBLIB
""
"NAME"
"COMPONENTS"
${ARGN}
)
# Because components are sources.cmake files, must know currently defined modules
# so we can pick up the newly defined ones
geant4_get_modules(__oldmodules)
# Load components
foreach(__comp ${G4GLOBLIB_COMPONENTS})
include(${__comp})
endforeach()
# Reset directory scope include dirs so we enforce usage requirements
set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES "")
# List modules now defined, and filter out old from new
geant4_get_modules(__newmodules)
if(__oldmodules)
list(REMOVE_ITEM __newmodules ${__oldmodules})
endif()
# Old function allowed optional NAME argument, in which case it should
# be the first element in the module list
if(NOT G4GLOBLIB_NAME)
list(GET __newmodules 0 G4GLOBLIB_NAME)
endif()
# Some compile definitions are still transported via directory level
# "add_definitions" calls at the site of the geant4_global_library call
# These, if they exist, are equivalent to PRIVATE level compile defs.
get_directory_property(__local_compile_defs COMPILE_DEFINITIONS)
foreach(__module ${__newmodules})
geant4_module_compile_definitions(${__module} PRIVATE ${__local_compile_defs})
endforeach()
# Compose the modules into the category
geant4_add_category(${G4GLOBLIB_NAME} MODULES ${__newmodules})
endfunction()
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: geant4_library_target
#
# .. code-block::
#
# geant4_library_target(NAME <name>
# SOURCES source1 [source2 ...]
# GEANT4_LINK_LIBRARIES lib1 [lib2 ...]
# LINK_LIBRARIES lib1 [lib2 ...])
#
# DEPRECATED: Maintained only for building internal G4clhep target because of its
# different include structure.
#
function(geant4_library_target)
cmake_parse_arguments(G4GLOBLIB
""
"NAME"
"SOURCES;GEANT4_LINK_LIBRARIES;LINK_LIBRARIES"
${ARGN}
)
# Currently a hack to get G4clhep to build, so an error if used elsewhere
if(NOT (${G4GLOBLIB_NAME} STREQUAL "G4clhep"))
message(FATAL_ERROR "geant4_library_target called for '${G4GLOBLIB_NAME}' in '${CMAKE_CURRENT_LIST_DIR}'")
endif()
geant4_format_target(NAME ${G4GLOBLIB_NAME}-format SOURCES ${G4GLOBLIB_SOURCES})
if(BUILD_SHARED_LIBS)
add_library(${G4GLOBLIB_NAME} SHARED ${G4GLOBLIB_SOURCES})
add_library(Geant4::${G4GLOBLIB_NAME} ALIAS ${G4GLOBLIB_NAME})
target_compile_features(${G4GLOBLIB_NAME} PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
target_compile_definitions(${G4GLOBLIB_NAME} PUBLIC G4LIB_BUILD_DLL)
target_include_directories(${G4GLOBLIB_NAME}
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
)
set_target_properties(${G4GLOBLIB_NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
install(TARGETS ${G4GLOBLIB_NAME}
EXPORT Geant4LibraryDepends
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Runtime
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Development
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
endif()
if(BUILD_STATIC_LIBS)
add_library(${G4GLOBLIB_NAME}-static STATIC ${G4GLOBLIB_SOURCES})
add_library(Geant4::${G4GLOBLIB_NAME}-static ALIAS ${G4GLOBLIB_NAME}-static)
target_compile_features(${G4GLOBLIB_NAME}-static PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
target_include_directories(${G4GLOBLIB_NAME}-static
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
)
if(NOT WIN32)
set_target_properties(${G4GLOBLIB_NAME}-static PROPERTIES OUTPUT_NAME ${G4GLOBLIB_NAME})
endif()
install(TARGETS ${G4GLOBLIB_NAME}-static
EXPORT Geant4LibraryDepends
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT Runtime
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Runtime
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Development
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME})
endif()
# Needs to be in defined category list for static/shared to be linked correctly.
set_property(GLOBAL APPEND PROPERTY GEANT4_DEFINED_CATEGORIES ${G4GLOBLIB_NAME})
endfunction()
#-----------------------------------------------------------------------
# .rst:
# .. cmake:command:: geant4_add_compile_definitions
#
# .. code-block:: cmake
#
# geant4_add_compile_definitions(SOURCES <source1> ... <sourceN>
# COMPILE_DEFINITIONS <def1> ... <defN>)
#
# Add extra compile definitions to a specific list of sources
# in the current module. Macroized to handle the need to specify absolute paths.
# and *must* be called at the same level as geant4_define_module
#
macro(geant4_add_compile_definitions)
cmake_parse_arguments(G4ADDDEF
""
""
"SOURCES;COMPILE_DEFINITIONS"
${ARGN}
)
# We assume that the sources have been added at the level of a
# a sources.cmake, so are inside the src subdir of the sources.cmake
get_filename_component(_ACD_BASE_PATH ${CMAKE_CURRENT_LIST_FILE} PATH)
# Now for each file, add the definitions
foreach(_acd_source ${G4ADDDEF_SOURCES})
# Extract any existing compile definitions
get_source_file_property(
_acd_existing_properties
${_ACD_BASE_PATH}/src/${_acd_source}
COMPILE_DEFINITIONS)
if(_acd_existing_properties)
set(_acd_new_defs ${_acd_existing_properties}
${G4ADDDEF_COMPILE_DEFINITIONS})
else()
set(_acd_new_defs ${G4ADDDEF_COMPILE_DEFINITIONS})
endif()
# quote compile defs because this must epand to space separated list
set_source_files_properties(${_ACD_BASE_PATH}/src/${_acd_source}
PROPERTIES COMPILE_DEFINITIONS "${_acd_new_defs}")
endforeach()
endmacro()
#-----------------------------------------------------------------------
#.rst:
# Internal Helper Commands
# ^^^^^^^^^^^^^^^^^^^^^^^^
#
# These macros and functions are for use in the implementation of the
# module and library functions. They should never be used directly
# in developer-level scripts.
#-----------------------------------------------------------------------
#.rst:
# .. cmake:command:: __geant4_module_assert_exists
#
# .. code-block:: cmake
#
# __geant4_module_assert_exists(<name>)
#
# Emit a ``FATAL_ERROR`` if the module ``<name>`` is not defined.
#
# This is a macro intended for use in G4DeveloperAPI functions when
# the existence of a module is required for further processing
#
macro(__geant4_module_assert_exists _module)
geant4_has_module(__geant4_module_assert_exists_tmp ${_module})
if(NOT __geant4_module_assert_exists_tmp)
message(FATAL_ERROR "Geant4 module '${_module}' has not been created")
endif()
endmacro()
#.rst:
# .. cmake:command:: __geant4_module_assert_not_exists
#
# .. code-block:: cmake
#
# __geant4_module_assert_not_exists(<name>)
#
# Emit a ``FATAL_ERROR`` if the module ``<name>`` is defined
#
# This is a macro intended for use in G4DeveloperAPI functions when
# the non-existence of a module is required for further processing
#
macro(__geant4_module_assert_not_exists _module)
geant4_has_module(__geant4_module_assert_not_exists_tmp ${_module})
if(__geant4_module_assert_not_exists_tmp)
geant4_get_module_property(__previous_cmake_list ${_module} CMAKE_LIST_FILE)
message(FATAL_ERROR "Geant4 module '${_module}' has already been created by call in '${__previous_cmake_list}'")
endif()
endmacro()
#.rst:
# .. cmake:command:: __geant4_module_validate_property
#
# .. code-block:: cmake
#
# __geant4_module_validate_property(<property>)
#
# Emit a ``FATAL_ERROR`` if the ``<property>`` is not one of the valid
# properties for a module:
#
# This is used internally by the property get/set functions.
#
function(__geant4_module_validate_property _property)
if(NOT (${_property} MATCHES "PUBLIC_HEADERS|PRIVATE_HEADERS|SOURCES|INTERFACE_COMPILE_DEFINITIONS|COMPILE_DEFINITIONS|INTERFACE_INCLUDE_DIRECTORIES|INCLUDE_DIRECTORIES|INTERFACE_LINK_LIBRARIES|LINK_LIBRARIES|PARENT_TARGET|CMAKE_LIST_FILE|GLOBAL_DEPENDENCIES"))
message(FATAL_ERROR "Undefined property '${_property}'")
endif()
endfunction()
#.rst:
# .. cmake:command:: __geant4_add_library
#
# .. code-block:: cmake
#
# __geant4_add_library(<libraryname> <mode>)
#
# Compose an actual CMake library target
#
# This is used internally by the ``geant4_compose_targets`` command.
#
function(__geant4_add_library _name _type)
# TEMP HACK: G4clhep/G4ptl are a special cases, and build is handled separately
if(_name MATCHES "G4clhep|G4ptl")
return()
endif()
if(NOT (${_type} MATCHES "SHARED|STATIC"))
message(FATAL_ERROR "Invalid library type '${_type}'")
endif()
# Get targets
get_property(__g4definedlibraries GLOBAL PROPERTY GEANT4_DEFINED_CATEGORIES)
set(_target_name ${_name})
if(_type STREQUAL "STATIC")
set(_target_name ${_name}-static)
endif()
# - General target creation/properties
add_library(${_target_name} ${_type} "")
# Alias for transparent use with imported targets
add_library(Geant4::${_target_name} ALIAS ${_target_name})
target_compile_features(${_target_name} PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
if(_type STREQUAL "SHARED")
# G4LIB_BUILD_DLL is public as despite the name it indicates the shared/archive mode
# and clients must apply it when linking to the shared libs. The global
# category handles the exact import/export statements
target_compile_definitions(${_target_name} PUBLIC G4LIB_BUILD_DLL)
set_target_properties(${_target_name} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
# MacOS
# Use '@rpath' in install names of libraries on macOS to provide relocatibility
# Add '@loader_path' to INSTALL_RPATH on macOS so that Geant4
# libraries self-locate each other whilst remaining relocatable
set_target_properties(${_target_name} PROPERTIES MACOSX_RPATH 1)
if(APPLE)
set_property(TARGET ${G4LIBTARGET_NAME} APPEND PROPERTY INSTALL_RPATH "@loader_path")
endif()
endif()
if((_type STREQUAL "STATIC") AND NOT WIN32)
set_target_properties(${_target_name} PROPERTIES OUTPUT_NAME ${_name})
endif()
# Compose target sources and links from its constituent modules
set(__sources_to_format)
get_property(__g4modules GLOBAL PROPERTY GEANT4_CATEGORIES_${_name}_MODULES)
foreach(__g4mod ${__g4modules})
# - Process sources...
geant4_get_module_property(_headers ${__g4mod} PUBLIC_HEADERS)
geant4_get_module_property(_srcs ${__g4mod} SOURCES)
geant4_get_module_property(_cmakescript ${__g4mod} CMAKE_LIST_FILE)
# Store sources to be formatted (one mode only)
if(_type STREQUAL "SHARED")
list(APPEND __sources_to_format ${_headers} ${_srcs})
endif()
# - Group sources and scripts for IDEs
# NB: Seemingly has to be done at same level we define target.
# TODO: If lib name is same as mod name, don't group avoid extra
# folder layer.
source_group(${__g4mod}\\Headers FILES ${_headers})
source_group(${__g4mod}\\Sources FILES ${_srcs})
source_group(${__g4mod} FILES ${_cmakescript})
# - Add sources to target - PRIVATE, because consuming targets don't need them
target_sources(${_target_name} PRIVATE ${_headers} ${_srcs} ${_cmakescript})
# - Process usage properties
# Include dirs and compile definitions can be handled together
# Important to note that these promote PUBLIC/PRIVATE/INTERFACE
# from module level to library level. I.e. other modules in the
# library can see each other's PRIVATE include paths/compile defs.
# The only known way to fully wall things off is OBJECT libs,
# but then run into issues mentioned at start - linking and
# use in IDEs.
# This "promotion" is probably correct though - interfaces are
# at physical library level rather than module, and in Geant4
# all files must have globally unique names (no nested hedaers
# nor namespaces). Also, DLL export symbols may need this
# behaviour (esp. ALLOC_EXPORT).
# Only really an issue if header names/definitions aren't
# globally (in Geant4) unique. Or if a module is moved and hasn't
# declared its deps correctly (but then an error will occur
# anyway, and point is that libs are linked, not modules!)
# "Module" level really means "Source file" level, so same
# sets of rules should apply (i.e. can't specify inc dirs
# at source level).
foreach(_prop IN ITEMS INCLUDE_DIRECTORIES INTERFACE_INCLUDE_DIRECTORIES COMPILE_DEFINITIONS INTERFACE_COMPILE_DEFINITIONS)
geant4_get_module_property(_value ${__g4mod} ${_prop})
set_property(TARGET ${_target_name} APPEND PROPERTY ${_prop} ${_value})
endforeach()
# Link libraries
foreach(_link_prop IN ITEMS LINK_LIBRARIES INTERFACE_LINK_LIBRARIES)
geant4_get_module_property(_linklibs ${__g4mod} ${_link_prop})
geant4_resolve_link_libraries(_linklibs)
# Remove self-linking
if(_linklibs)
list(REMOVE_ITEM _linklibs ${_name})
endif()
# Filter list for internal static targets
if(_type STREQUAL "STATIC")
set(_g4linklibs )
foreach(_linklib ${_linklibs})
# If the linklib is a G4Library, change name to "name-static"
list(FIND __g4definedlibraries ${_linklib} _isg4lib)
if(_isg4lib GREATER -1)
list(APPEND _g4linklibs "${_linklib}-static")
else()
list(APPEND _g4linklibs "${_linklib}")
endif()
endforeach()
set(_linklibs ${_g4linklibs})
endif()
set_property(TARGET ${_target_name} APPEND PROPERTY ${_link_prop} ${_linklibs})
# Temp workaround for modules needing Qt. We use AUTOMOC, but can't yet set
# it on a per module basis. However, only have three modules that require
# moc-ing, so hard code for now.
# TODO: likely need an additional "module target properties" to hold things
# that can be passed to set_target_properties
if(__g4mod MATCHES "G4UIbasic|G4OpenGL|G4OpenInventor" AND GEANT4_USE_QT)
set_target_properties(${_target_name} PROPERTIES AUTOMOC ON)
endif()
endforeach()
endforeach()
# - Use stored total list of sources to create format target for one mode only
if(_type STREQUAL "SHARED")
geant4_format_target(NAME ${_name}-format SOURCES ${__sources_to_format})
endif()
# - Postprocess target properties to remove duplicates
foreach(_link_prop IN ITEMS LINK_LIBRARIES INTERFACE_LINK_LIBRARIES INCLUDE_DIRECTORIES INTERFACE_INCLUDE_DIRECTORIES COMPILE_DEFINITIONS INTERFACE_COMPILE_DEFINITIONS)
get_target_property(__g4lib_link_libs ${_target_name} ${_link_prop})
if(__g4lib_link_libs)
list(SORT __g4lib_link_libs)
list(REMOVE_DUPLICATES __g4lib_link_libs)
set_property(TARGET ${_target_name} PROPERTY ${_link_prop} ${__g4lib_link_libs})
endif()
endforeach()
endfunction()
cmake/Modules/G4DeveloperAPI_OLD.cmake
+13 -7
View File
@@ -239,9 +239,13 @@ macro(geant4_library_target)
add_library(${G4LIBTARGET_NAME} SHARED ${G4LIBTARGET_SOURCES})
target_compile_definitions(${G4LIBTARGET_NAME} PRIVATE GEANT4_DEVELOPER_$<CONFIG>)
target_compile_features(${G4LIBTARGET_NAME} PUBLIC ${GEANT4_TARGET_COMPILE_FEATURES})
target_link_libraries(${G4LIBTARGET_NAME}
${G4LIBTARGET_GEANT4_LINK_LIBRARIES}
${G4LIBTARGET_LINK_LIBRARIES})
set(__sorted_link_libs ${G4LIBTARGET_GEANT4_LINK_LIBRARIES} ${G4LIBTARGET_LINK_LIBRARIES})
if(__sorted_link_libs)
list(SORT __sorted_link_libs)
endif()
target_link_libraries(${G4LIBTARGET_NAME} ${__sorted_link_libs})
# DLL support, portable to all platforms
# G4LIB_BUILD_DLL is public as despite the name it indicates the shared/archive mode
# and clients must apply it when linking to the shared libs. The global
@@ -305,14 +309,16 @@ macro(geant4_library_target)
# Because externals like clhep appear in G4LIBTARGET_LINK_LIBRARIES,
# filter this list to replace shared builtins with their static variant
string(REGEX REPLACE
"(G4clhep|G4expat|G4zlib|G4geomUSolids)(;|$)" "\\1-static\\2"
"(G4clhep|G4expat|G4zlib|G4ptl|G4geomUSolids)(;|$)" "\\1-static\\2"
G4LIBTARGET_LINK_LIBRARIES_STATIC
"${G4LIBTARGET_LINK_LIBRARIES}"
)
target_link_libraries(${G4LIBTARGET_NAME}-static PUBLIC
${G4LIBTARGET_GEANT4_LINK_LIBRARIES_STATIC}
${G4LIBTARGET_LINK_LIBRARIES_STATIC})
set(__sorted_link_libs ${G4LIBTARGET_GEANT4_LINK_LIBRARIES_STATIC} ${G4LIBTARGET_LINK_LIBRARIES_STATIC})
if(__sorted_link_libs)
list(SORT __sorted_link_libs)
endif()
target_link_libraries(${G4LIBTARGET_NAME}-static PUBLIC ${__sorted_link_libs})
# But we can rename the output library to the correct name
# On WIN32 we *retain* the -static postfix to avoid name clashes
cmake/Modules/Geant4InstallData.cmake → cmake/Modules/G4InstallData.cmake
+1 -1
View File
@@ -108,7 +108,7 @@ set(GEANT4_BUILD_FULL_DATADIR ${PROJECT_BINARY_DIR}/data)
set(GEANT4_INSTALL_DATADIR_DEFAULT "${CMAKE_INSTALL_DATADIR}/data")
# File containing dataset list
set(GEANT4_DATASETS_DEFINITIONS "Geant4DatasetDefinitions")
set(GEANT4_DATASETS_DEFINITIONS "G4DatasetDefinitions")
#-----------------------------------------------------------------------
cmake/Modules/Geant4InterfaceOptions.cmake → cmake/Modules/G4InterfaceOptions.cmake
+34 -60
View File
@@ -42,6 +42,12 @@ set(OpenGL_GL_PREFERENCE "LEGACY")
# Configure OpenInventor support
#
option(GEANT4_USE_INVENTOR "Build Geant4 OpenInventor Visualization Driver" OFF)
option(GEANT4_USE_INVENTOR_QT "Build Geant4 OpenInventor Qt Visualization Driver" OFF)
if(GEANT4_USE_INVENTOR_QT)
set(GEANT4_USE_INVENTOR ON)
set(GEANT4_USE_QT ON)
endif()
if(GEANT4_USE_INVENTOR)
# Always need Inventor and OpenGL
@@ -50,16 +56,20 @@ if(GEANT4_USE_INVENTOR)
# On UNIX, we also require Xm and X11 (inc. Xpm)...
if(UNIX)
if(NOT INVENTOR_SOXT_LIBRARY OR NOT INVENTOR_SOXT_INCLUDE_DIR)
message(FATAL_ERROR "Could not find SoXt library and/or headers")
endif()
if (GEANT4_USE_INVENTOR_QT)
if (NOT INVENTOR_SOQT_LIBRARY OR NOT INVENTOR_SOQT_INCLUDE_DIR)
message(FATAL_ERROR "Could not find SoQt library and/or headers")
endif()
set(INVENTOR_INCLUDE_DIR "${INVENTOR_INCLUDE_DIR}" "${INVENTOR_SOQT_INCLUDE_DIR}")
else()
if(NOT INVENTOR_SOXT_LIBRARY OR NOT INVENTOR_SOXT_INCLUDE_DIR)
message(FATAL_ERROR "Could not find SoXt library and/or headers")
endif()
set(INVENTOR_INCLUDE_DIR "${INVENTOR_INCLUDE_DIR}" "${INVENTOR_SOXT_INCLUDE_DIR}")
set(GEANT4_USE_XM ON)
find_package(Motif REQUIRED)
endif()
set(INVENTOR_INCLUDE_DIR "${INVENTOR_INCLUDE_DIR}" "${INVENTOR_SOXT_INCLUDE_DIR}")
find_package(Motif REQUIRED)
find_package(X11 REQUIRED)
if(NOT X11_Xpm_FOUND)
@@ -74,63 +84,27 @@ endif()
#-----------------------------------------------------------------------
# Configure Qt Support if needed (CROSSPLATFORM).
#
option(GEANT4_USE_QT "Build Geant4 with Qt support (Qt5 preferred, Qt4 fallback)" OFF)
option(GEANT4_USE_QT "Build Geant4 with Qt support" OFF)
if(GEANT4_USE_QT)
# Find and configure Qt and OpenGL - Search for 5 first, then 4
find_package(Qt5Core QUIET)
find_package(Qt5Gui QUIET)
find_package(Qt5Widgets QUIET)
find_package(Qt5OpenGL QUIET)
find_package(Qt5PrintSupport QUIET)
# Find and configure Qt and OpenGL
find_package(Qt5Core REQUIRED)
find_package(Qt5Gui REQUIRED)
find_package(Qt5Widgets REQUIRED)
find_package(Qt5OpenGL REQUIRED)
find_package(Qt5PrintSupport REQUIRED)
if(Qt5Core_FOUND
AND Qt5Gui_FOUND
AND Qt5Widgets_FOUND
AND Qt5OpenGL_FOUND
AND Qt5PrintSupport_FOUND)
# Compatibility
macro(qt4_wrap_cpp)
qt5_wrap_cpp(${ARGN})
endmacro()
# 4/5 Compatibility
set(QT_QTCORE_LIBRARY Qt5::Core Qt5::PrintSupport)
set(QT_QTGUI_LIBRARY Qt5::Gui Qt5::Widgets)
set(QT_OPENGL_LIBRARY Qt5::Gui Qt5::OpenGL)
set(QT_LIBRARIES Qt5::OpenGL Qt5::Gui Qt5::PrintSupport Qt5::Widgets)
get_target_property(QT_QMAKE_EXECUTABLE ${Qt5Core_QMAKE_EXECUTABLE} IMPORTED_LOCATION)
geant4_save_package_variables(Qt5 Qt5Core_DIR Qt5Gui_DIR Qt5Widgets_DIR Qt5OpenGL_DIR Qt5PrintSupport_DIR)
else()
unset(Qt5Core_DIR CACHE)
unset(Qt5Gui_DIR CACHE)
unset(Qt5Widgets_DIR CACHE)
unset(Qt5OpenGL_DIR CACHE)
unset(Qt5PrintSupport_DIR CACHE)
# On WIN32 only, set QT_USE_IMPORTED_TARGETS. The Qt4 module will
# otherwise set QT_LIBRARIES using the 'optimized A; debug Ad'
# technique.
if(WIN32)
set(QT_USE_IMPORTED_TARGETS ON)
endif()
find_package(Qt4 REQUIRED COMPONENTS QtCore QtGui QtOpenGL)
if(Qt4_FOUND)
message(WARNING "Support for Qt4 in Geant4 is now deprecated and will be removed in the next release")
endif()
# 4/5 Compatibility
set(QT_QTCORE_LIBRARY Qt4::QtCore)
set(QT_QTGUI_LIBRARY Qt4::QtGui)
set(QT_OPENGL_LIBRARY Qt4::QtOpenGL)
set(QT_LIBRARIES Qt4::QtOpenGL Qt4::QtGui)
geant4_save_package_variables(Qt4 QT_QMAKE_EXECUTABLE)
endif()
set(QT_QTCORE_LIBRARY Qt5::Core Qt5::PrintSupport)
set(QT_QTGUI_LIBRARY Qt5::Gui Qt5::Widgets)
set(QT_OPENGL_LIBRARY Qt5::Gui Qt5::OpenGL)
set(QT_LIBRARIES Qt5::OpenGL Qt5::Gui Qt5::PrintSupport Qt5::Widgets)
get_target_property(QT_QMAKE_EXECUTABLE ${Qt5Core_QMAKE_EXECUTABLE} IMPORTED_LOCATION)
geant4_save_package_variables(Qt5 Qt5Core_DIR Qt5Gui_DIR Qt5Widgets_DIR Qt5OpenGL_DIR Qt5PrintSupport_DIR)
find_package(OpenGL REQUIRED)
geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY OPENGL_glu_LIBRARY)
geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY)
# Variables for export
# Variables for export to GNUmake
execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} -query QT_INSTALL_PREFIX OUTPUT_VARIABLE G4QTHOME OUTPUT_STRIP_TRAILING_WHITESPACE)
execute_process(COMMAND ${QT_QMAKE_EXECUTABLE} -query QT_INSTALL_LIBS OUTPUT_VARIABLE G4QTLIBPATH OUTPUT_STRIP_TRAILING_WHITESPACE)
@@ -157,7 +131,7 @@ set(GEANT4_USE_WT OFF)
# find_package(OpenGL REQUIRED)
#
# geant4_save_package_variables(Wt Wt_INCLUDE_DIR Wt_LIBRARY_RELEASE Wt_LIBRARY_DEBUG Wt_HTTP_LIBRARY_RELEASE Wt_HTTP_LIBRARY_DEBUG)
# geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY OPENGL_glu_LIBRARY)
# geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY)
#
# set(WT_DEFINITIONS "-DQT_NO_KEYWORDS")
#
@@ -238,12 +212,12 @@ if(UNIX)
if(GEANT4_USE_INVENTOR OR GEANT4_USE_XM OR GEANT4_USE_OPENGL_X11)
# - Find native GL first
find_package(OpenGL REQUIRED)
geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY OPENGL_glu_LIBRARY)
geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY)
# - If we're on Apple, also find the XQuartz GL libraries and append t.
if(APPLE)
find_package(XQuartzGL REQUIRED)
geant4_save_package_variables(XQuartzGL XQuartzGL_INCLUDE_DIR XQuartzGL_gl_LIBRARY XQuartzGL_glu_LIBRARY)
geant4_save_package_variables(XQuartzGL XQuartzGL_INCLUDE_DIR XQuartzGL_gl_LIBRARY)
endif()
# Add feature for X11 GL
@@ -278,7 +252,7 @@ if(WIN32)
# This is part of the G4OpenGL component, so mark it as needed
set(GEANT4_USE_OPENGL ON)
geant4_add_feature(GEANT4_USE_OPENGL_WIN32 "Build OpenGL driver with Win32 support")
geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY OPENGL_glu_LIBRARY)
geant4_save_package_variables(OpenGL OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY)
endif()
endif()
cmake/Modules/Geant4MakeRules_cxx.cmake → cmake/Modules/G4MakeRules_cxx.cmake
View File
cmake/Modules/Geant4OptionalComponents.cmake → cmake/Modules/G4OptionalComponents.cmake
+43 -2
View File
@@ -153,6 +153,41 @@ endif()
geant4_add_feature(GEANT4_USE_SYSTEM_ZLIB "Using system zlib library")
#-----------------------------------------------------------------------
# TBB support
#
set(_default_use_tbb OFF)
if(TBB_DIR)
set(_default_use_tbb ON)
endif()
option(GEANT4_USE_TBB "Enable (optional) use of TBB as a tasking backend" ${_default_use_tbb})
if(GEANT4_USE_TBB)
find_package(TBB REQUIRED)
geant4_save_package_variables(TBB TBB_INCLUDE_DIR TBB_LIBRARY TBB_LIBRARY_DEBUG
TBB_LIBRARY_RELEASE TBB_ROOT_DIR)
endif()
geant4_add_feature(GEANT4_USE_TBB "Enable (optional) use of TBB as a tasking backend")
#-----------------------------------------------------------------------
# Find required PTL package, defaulting in internal
# Rely on PTL::PTL imported target (since CMake 3.1)
option(GEANT4_USE_SYSTEM_PTL "Use system zlib library" OFF)
if(GEANT4_USE_SYSTEM_PTL)
find_package(PTL REQUIRED)
# Backward compatibility for sources.cmake using the variable
set(PTL_LIBRARIES PTL::PTL)
geant4_save_package_variables(PTL PTL_DIR)
else()
set(PTL_USE_TBB ${GEANT4_USE_TBB})
set(PTL_FOUND TRUE)
set(GEANT4_USE_BUILTIN_PTL TRUE)
set(PTL_LIBRARIES G4ptl)
endif()
geant4_add_feature(GEANT4_USE_SYSTEM_PTL "Using system PTL library")
#-----------------------------------------------------------------------
# Optional Support for GDML - requires Xerces-C package
# Relies on XercesC::XercesC imported target (since CMake 3.5)
@@ -191,7 +226,7 @@ geant4_add_feature(GEANT4_USE_SMARTSTACK "Use smart track stack")
# easily installed via:
# git clone https://github.com/NERSC/timemory.git timemory
# pip install -vvv ./timemory
# and setting timemory_DIR to `python -c "import sys; print(sys.prefix)"`
# and prepending CMAKE_PREFIX_PATH with `python -c "import sys; print(sys.prefix)"`
#
set(_default_use_timemory OFF)
if(TiMemory_DIR)
@@ -295,10 +330,16 @@ if(GEANT4_USE_ALL_USOLIDS OR GEANT4_USE_PARTIAL_USOLIDS)
# Shim until VecGeom supports config mode properly
include("${CMAKE_CURRENT_LIST_DIR}/G4VecGeomShim.cmake")
# Backward Compatibility
set(VECGEOM_LIBRARIES VecGeom::VecGeom)
set(VECGEOM_LIBRARIES VecGeom::vecgeom)
geant4_save_package_variables(VecGeom VecGeom_DIR)
# If VecCore_DIR is set, means updated VecGeom install used, so
# also store VecCore_DIR
if(VecCore_DIR)
geant4_save_package_variables(VecGeom VecCore_DIR)
endif()
if(GEANT4_USE_ALL_USOLIDS)
set(G4GEOM_USE_USOLIDS TRUE)
GEANT4_ADD_FEATURE(GEANT4_USE_USOLIDS "Replacing Geant4 solids with all VecGeom equivalents (EXPERIMENTAL)")
cmake/Modules/Geant4TestDriver.cmake → cmake/Modules/G4TestDriver.cmake
View File
cmake/Modules/G4VecGeomShim.cmake
+3 -3
View File
@@ -1,7 +1,7 @@
# Create imported target to help use VecGeom (a mess because the VecGeomConfig is...)
if(VecGeom_FOUND)
if(NOT TARGET VecGeom::VecGeom)
add_library(VecGeom::VecGeom UNKNOWN IMPORTED)
if(NOT TARGET VecGeom::vecgeom)
add_library(VecGeom::vecgeom UNKNOWN IMPORTED)
# VecGeom's config file is awful, so the following is neccessary...
foreach(__vglib ${VECGEOM_LIBRARIES})
if(__vglib MATCHES ".*libvecgeom\.(a|so|dylib|lib|dll)$")
@@ -10,7 +10,7 @@ if(VecGeom_FOUND)
endforeach()
string(REGEX REPLACE "^\-D|;-D" ";" VECGEOM_COMPILE_DEFINITIONS "${VECGEOM_DEFINITIONS}")
set_target_properties(VecGeom::VecGeom PROPERTIES
set_target_properties(VecGeom::vecgeom PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "${VECGEOM_COMPILE_DEFINITIONS}"
INTERFACE_INCLUDE_DIRECTORIES "${VECGEOM_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${VECGEOM_LIBRARIES}"
cmake/Modules/IntelCompileFeatures.cmake
-2
View File
@@ -25,6 +25,4 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
endif()
endif()
endif()
endif()