Geant4 Cross Reference |
1 # - Geant4 CMake Configuration File for Extern 1 # - Geant4 CMake Configuration File for External Projects 2 # This file is configured by Geant4 for use by 2 # This file is configured by Geant4 for use by an external project 3 # This file is configured by Geant4's CMake sy 3 # This file is configured by Geant4's CMake system and SHOULD NOT BE EDITED 4 # 4 # 5 # It defines the following variables 5 # It defines the following variables 6 # Geant4_INCLUDE_DIRS - include directories f 6 # Geant4_INCLUDE_DIRS - include directories for Geant4 >> 7 # Geant4_DEFINITIONS - compile definitions needed to use Geant4 7 # Geant4_LIBRARIES - libraries to link aga 8 # Geant4_LIBRARIES - libraries to link against 8 # Geant4_BUILD_TYPE - Build type (e.g. "Rel << 9 # install. Only set if << 10 # a single mode tool (e << 11 # Geant4_CXX_FLAGS - Recommended CXX flags 9 # Geant4_CXX_FLAGS - Recommended CXX flags for the compiler used to 12 # build the Geant4 libr 10 # build the Geant4 libraries. 13 # Geant4_CXX_FLAGS_<CONFIG> - Recommended CXX 11 # Geant4_CXX_FLAGS_<CONFIG> - Recommended CXX flags for build mode CONFIG. 14 # Geant4_USE_FILE - path to a CMake modul 12 # Geant4_USE_FILE - path to a CMake module which may be included to 15 # help setup CMake vari 13 # help setup CMake variables 16 # Geant4_CXXSTD - C++ Standard used to << 17 # Geant4_TLS_MODEL - Thread Local Storage << 18 # the build used an exp << 19 # 14 # 20 # You may supply a version number through find 15 # You may supply a version number through find_package which will be checked 21 # against the version of this build. Standard 16 # against the version of this build. Standard CMake logic is used so that 22 # the EXACT flag may be passed, and otherwise 17 # the EXACT flag may be passed, and otherwise this build will report itself 23 # as compatible with the requested version if: 18 # as compatible with the requested version if: 24 # 19 # 25 # VERSION_OF_THIS_BUILD >= VERSION_REQUESTED 20 # VERSION_OF_THIS_BUILD >= VERSION_REQUESTED 26 # 21 # 27 # By default only the core (or kernel) of Gean 22 # By default only the core (or kernel) of Geant4 is activated by this 28 # module. You can specify additional component 23 # module. You can specify additional components of Geant4 through the 29 # COMPONENTS argument to find_package. By defa 24 # COMPONENTS argument to find_package. By default, all core libraries of 30 # Geant4 are appended to the Geant4_LIBRARIES << 25 # Geant4 are appended to the Geant4_LIBRARIES variable. Specifiying 31 # additional components will enable a check on 26 # additional components will enable a check on the existence of these 32 # components, with the following per component 27 # components, with the following per component variables being set: 33 # 28 # 34 # Geant4_${COMPONENT}_FOUND TRUE is the Ge 29 # Geant4_${COMPONENT}_FOUND TRUE is the Geant4 library "component" was 35 # found 30 # found 36 # 31 # 37 # Geant4_${COMPONENT}_LIBRARY Contains the l 32 # Geant4_${COMPONENT}_LIBRARY Contains the library for the specified 38 # "component" IF 33 # "component" IF the component is a library. 39 # 34 # 40 # In Geant4, components can be optional subcom 35 # In Geant4, components can be optional subcomponents of an always 41 # available library. In that case there will b 36 # available library. In that case there will be no 42 # Geant4_{COMPONENT}_LIBRARY variable. These n 37 # Geant4_{COMPONENT}_LIBRARY variable. These non-library components are 43 # generally activated by compile definitions t << 38 # generally activated by compile definitions, and in these cases the 44 # COMPILE_DEFINITIONS property. << 39 # appropriate definition will be added to the Geant4_DEFINITIONS component. 45 # 40 # 46 # If you use the REQUIRED and/or COMPONENTS ar << 41 # If you specify components and use the REQUIRED option to find_package, 47 # specify components, then the module will iss << 42 # then the module will issue a FATAL_ERROR if this build of Geant4 does 48 # found Geant4 does not have the requested com << 43 # not have the requested component(s). 49 # specified through the OPTIONAL_COMPONENTS ar << 50 # only if the found Geant4 supports them, with << 51 # they are not supported. << 52 # << 53 # The components available generally correspon << 54 # the Geant4 libraries or optional extras that << 55 # << 56 # Library Configuration << 57 # --------------------- << 58 # static (Static libraries availab << 59 # when static libraries ar << 60 # Geant4_LIBRARIES being p << 61 # versions of the Geant4 l << 62 # guarantee the use of sta << 63 # multithreaded (Libraries are multithrea << 64 # 44 # 65 # usolids (Geant4 solids are replac << 45 # The list of components available generally corresponds to the optional >> 46 # extras that Geant4 can be built with and are: 66 # 47 # 67 # smartstack (G4event library G4StackM << 48 # multithreaded (Libraries built with multithreading support) 68 # 49 # 69 # php_as_hp (G4processes library Part << 70 # << 71 # Optional Components << 72 # ------------------- << 73 # gdml (GDML support) 50 # gdml (GDML support) 74 # g3tog4 (Geant3 geometry call lis 51 # g3tog4 (Geant3 geometry call list reader library) 75 # freetype (G4analysis library has f << 76 # hdf5 (G4analysis library has H << 77 # 52 # 78 # ui_tcsh (TCsh Style Application C 53 # ui_tcsh (TCsh Style Application Command Line Interface) 79 # ui_win32 (WIN32 Style Application 54 # ui_win32 (WIN32 Style Application Command Line Interface) 80 # 55 # 81 # motif (Motif-X11/OpenGL Graphic 56 # motif (Motif-X11/OpenGL Graphical User Interface) 82 # qt (Qt/OpenGL Graphical User << 57 # qt (Qt4/OpenGL Graphical User Interface) >> 58 # wt (Wt/OpenGL Web based Graphical User Interface) 83 # 59 # 84 # vis_Vtk (VTK Graphical User Inter << 60 # vis_network_dawn (Client/Server network interface to DAWN visualization) 85 # vis_openinventor (OpenInventor visualizati << 61 # vis_network_vrml (Client/Server network interface to VRML visualization) 86 # vis_opengl_x11 (OpenGL visualization wit 62 # vis_opengl_x11 (OpenGL visualization with X11 interface) 87 # vis_opengl_win32 (OpenGL visualization wit 63 # vis_opengl_win32 (OpenGL visualization with X11 interface) 88 # vis_raytracer_x11 (RayTracer visualization 64 # vis_raytracer_x11 (RayTracer visualization with X11 interface) >> 65 # vis_openinventor (OpenInventor visualization) 89 # 66 # 90 # In addition, two 'shorthand' components are 67 # In addition, two 'shorthand' components are defined to help activate all 91 # available User Interface and Visualization d 68 # available User Interface and Visualization drivers: 92 # 69 # 93 # ui_all (All available UI drivers 70 # ui_all (All available UI drivers) 94 # vis_all (All available Vis driver 71 # vis_all (All available Vis drivers) 95 # 72 # 96 # These never result in a FATAL_ERROR, even if 73 # These never result in a FATAL_ERROR, even if the REQUIRED find_package 97 # argument is set. This is because these optio 74 # argument is set. This is because these options do not depend on specific 98 # components being available. 75 # components being available. 99 # 76 # 100 # You can also query whether the Geant4 found << 77 # You can also query Geant4's use, or otherwise, of its builtin versions 101 # versions of CLHEP, ZLIB, or Expat after call << 78 # of CLHEP, ZLIB and Expat after calling find_package via the variables 102 # 79 # 103 # Geant4_builtin_clhep_FOUND (TRUE if Geant << 80 # Geant4_builtin_clhep_FOUND (TRUE if Geant4 built with internal CLHEP) 104 # Geant4_system_clhep_FOUND (TRUE if Geant << 81 # Geant4_builtin_expat_FOUND (TRUE if Geant4 built with internal Expat) 105 # Geant4_builtin_expat_FOUND (TRUE if Geant << 82 # Geant4_builtin_zlib_FOUND (TRUE if Geant4 built with internal Zlib) 106 # Geant4_builtin_zlib_FOUND (TRUE if Geant << 107 # 83 # 108 # These are not used via components as they do 84 # These are not used via components as they do not, in general, affect 109 # the use of Geant4 in an application unless y 85 # the use of Geant4 in an application unless you yourself make direct 110 # calls to these APIs. As the builtin librarie 86 # calls to these APIs. As the builtin libraries only contain the code 111 # required directly by the Geant4 toolkit, you 87 # required directly by the Geant4 toolkit, you may wish to perform a 112 # configure time check in these cases that the 88 # configure time check in these cases that the builtin libraries contain 113 # the calls required. In both cases, the Geant 89 # the calls required. In both cases, the Geant4_INCLUDE_DIRS and 114 # Geant4_LIBRARIES variables will be populated 90 # Geant4_LIBRARIES variables will be populated to use the builtin or 115 # system APIs as required, and you should use 91 # system APIs as required, and you should use these to ensure you compile 116 # and link against the same API version. 92 # and link against the same API version. 117 # 93 # 118 # Environment variables for, and directory pat << 94 # Environment variables for and directory paths to physics datasets 119 # used by some Geant4 physics processes may be 95 # used by some Geant4 physics processes may be determined from the 120 # variables 96 # variables 121 # 97 # 122 # Geant4_DATASETS (List of data 98 # Geant4_DATASETS (List of dataset names known to Geant4) 123 # Geant4_DATASET_<NAME>_ENVVAR (Name of envi 99 # Geant4_DATASET_<NAME>_ENVVAR (Name of environment variable used by 124 # Geant4 to ob << 100 # Geant4 to query for path to dataset 125 # <NAME>) 101 # <NAME>) 126 # Geant4_DATASET_<NAME>_PATH (Path to data 102 # Geant4_DATASET_<NAME>_PATH (Path to dataset <NAME>. NB this may 127 # point to a n 103 # point to a non-existent path if Geant4 128 # was configur 104 # was configured not to install data) 129 # 105 # 130 #--------------------------------------------- 106 #----------------------------------------------------------------------- 131 # Variables used by this module which can chan 107 # Variables used by this module which can change the default behaviour of 132 # this module. They need to be set prior to th 108 # this module. They need to be set prior to the call to find_package 133 # 109 # 134 # Geant4_CONFIG_DEBUG If set, enable extra 110 # Geant4_CONFIG_DEBUG If set, enable extra messaging output which can 135 # be helpful in debugg 111 # be helpful in debugging and identifying problems 136 # with the configurati 112 # with the configuration. 137 # 113 # 138 #--------------------------------------------- 114 #----------------------------------------------------------------------- 139 115 140 #--------------------------------------------- 116 #----------------------------------------------------------------------- 141 # DEBUG : print out the variables passed via f 117 # DEBUG : print out the variables passed via find_package arguments 142 # 118 # 143 if(Geant4_CONFIG_DEBUG) 119 if(Geant4_CONFIG_DEBUG) 144 message(STATUS "G4CFG_DEBUG : Geant4_VERSION 120 message(STATUS "G4CFG_DEBUG : Geant4_VERSION = ${Geant4_VERSION}") 145 message(STATUS "G4CFG_DEBUG : Geant4_FIND_VE 121 message(STATUS "G4CFG_DEBUG : Geant4_FIND_VERSION = ${Geant4_FIND_VERSION}") 146 message(STATUS "G4CFG_DEBUG : Geant4_FIND_RE 122 message(STATUS "G4CFG_DEBUG : Geant4_FIND_REQUIRED = ${Geant4_FIND_REQUIRED}") 147 message(STATUS "G4CFG_DEBUG : Geant4_FIND_CO 123 message(STATUS "G4CFG_DEBUG : Geant4_FIND_COMPONENTS = ${Geant4_FIND_COMPONENTS}") 148 124 149 foreach(_cpt ${Geant4_FIND_COMPONENTS}) 125 foreach(_cpt ${Geant4_FIND_COMPONENTS}) 150 message(STATUS "G4CFG_DEBUG : Geant4_FIND_ 126 message(STATUS "G4CFG_DEBUG : Geant4_FIND_REQUIRED_${_cpt} = ${Geant4_FIND_REQUIRED_${_cpt}}") 151 endforeach() 127 endforeach() 152 128 153 message(STATUS "G4CFG_DEBUG : Geant4_LIBDEPS 129 message(STATUS "G4CFG_DEBUG : Geant4_LIBDEPS_LOADED = ${Geant4_LIBDEPS_LOADED}") 154 endif() 130 endif() 155 131 156 #--------------------------------------------- 132 #----------------------------------------------------------------------- 157 # Check that consumers use the minimum needed << 158 # Geant4 uses cxx_std_EP to define the standar << 159 # 3.8 and above support EP=17. 3.12 and above << 160 # We continue to support the earlier version w << 161 cmake_policy(VERSION 3.8...3.18) << 162 if(CMAKE_VERSION VERSION_LESS 3.8) << 163 message(FATAL_ERROR "Projects consuming Gean << 164 endif() << 165 << 166 if(("@CMAKE_CXX_STANDARD@" GREATER_EQUAL 23) A << 167 message(FATAL_ERROR "Projects consuming Gean << 168 endif() << 169 << 170 if(("@CMAKE_CXX_STANDARD@" GREATER_EQUAL 20) A << 171 message(FATAL_ERROR "Projects consuming Gean << 172 endif() << 173 << 174 # - Help find dependencies << 175 include(CMakeFindDependencyMacro) << 176 << 177 #--------------------------------------------- << 178 # Locate ourselves, since all other config fil 133 # Locate ourselves, since all other config files should have been 179 # installed alongside us... 134 # installed alongside us... 180 # 135 # 181 get_filename_component(_geant4_thisdir "${CMAK << 136 get_filename_component(_thisdir "${CMAKE_CURRENT_LIST_FILE}" PATH) 182 137 183 #--------------------------------------------- 138 #----------------------------------------------------------------------- 184 # Provide *recommended* compiler flags used by 139 # Provide *recommended* compiler flags used by this build of Geant4 185 # Don't mess with the actual CMAKE_CXX_FLAGS!! 140 # Don't mess with the actual CMAKE_CXX_FLAGS!!! 186 # It's up to the user what to do with these 141 # It's up to the user what to do with these 187 @GEANT4_COMPILER_FLAG_HINTS@ 142 @GEANT4_COMPILER_FLAG_HINTS@ 188 143 189 # - Provide variable indicating C++ Standard w << 144 #----------------------------------------------------------------------- 190 set(Geant4_CXX_STANDARD "@CMAKE_CXX_STANDARD@" << 145 # Set the base compile definitions required to use Geant4 if the variable >> 146 # does not exist (we do this to ensure multiple calls to find_package >> 147 # don't overwrite previous invocations) >> 148 # Components may append to this >> 149 # We set VIS/UI_USE directly here, because for now they are, unfortunately, >> 150 # always needed for the Examples. >> 151 # However, they ARE NOT required to use Geant4 itself. >> 152 # >> 153 if(NOT Geant4_DEFINITIONS) >> 154 set(Geant4_DEFINITIONS @GEANT4_CORE_DEFINITIONS@) >> 155 endif() >> 156 >> 157 # We set VIS/UI_USE directly here, because for now they are, unfortunately, >> 158 # always needed for the Examples. >> 159 # However, they ARE NOT required to use Geant4 itself. >> 160 # >> 161 if(NOT G4UI_NONE) >> 162 list(APPEND Geant4_DEFINITIONS -DG4UI_USE) >> 163 endif() >> 164 >> 165 if(NOT G4VIS_NONE) >> 166 list(APPEND Geant4_DEFINITIONS -DG4VIS_USE) >> 167 endif() 191 168 192 #--------------------------------------------- 169 #----------------------------------------------------------------------- 193 # Configure the path to the Geant4 headers, us 170 # Configure the path to the Geant4 headers, using a relative path if 194 # possible. This is only known at CMake time, 171 # possible. This is only known at CMake time, so we expand a CMake 195 # supplied variable. 172 # supplied variable. 196 # 173 # 197 @GEANT4_INCLUDE_DIR_SETUP@ 174 @GEANT4_INCLUDE_DIR_SETUP@ 198 set(Geant4_INCLUDE_DIRS "${Geant4_INCLUDE_DIR} << 199 175 200 # Push our own module path onto the CMake one << 176 @GEANT4_MODULE_PATH_SETUP@ 201 # - Popped at end of this module << 177 202 list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRE << 178 #----------------------------------------------------------------------- >> 179 # Configure the path(s) to third party headers. >> 180 # This is not a perfect solution to recording dependencies on external >> 181 # libraries, but it does ensure that users of THIS Geant4 will pick up >> 182 # those it was built against. >> 183 # Library dependencies are generally handled through the >> 184 # Geant4LibraryDepends file listed below (apart from one exception!) >> 185 # >> 186 set(Geant4_THIRD_PARTY_INCLUDE_DIRS @GEANT4_THIRD_PARTY_INCLUDES@) >> 187 >> 188 #----------------------------------------------------------------------- >> 189 # Construct overall include path for using Geant4 >> 190 # >> 191 set(Geant4_INCLUDE_DIRS >> 192 ${Geant4_INCLUDE_DIR} >> 193 ${Geant4_THIRD_PARTY_INCLUDE_DIRS}) >> 194 >> 195 #----------------------------------------------------------------------- >> 196 # If we have used imported targets for any third party packages, reimport >> 197 # them here, BEFORE we try and import the Geant4 targets which are >> 198 # linked against them. >> 199 # Generally, we try and use a standard find_package, but try and force it >> 200 # to find the actual package we were built against. >> 201 # THIS IS NOT PERFECT, AS IT CANNOT GUARANTEE A BINARY COMPATIBLE >> 202 # PACKAGE IS FOUND. >> 203 @GEANT4_THIRD_PARTY_IMPORT_SETUP@ >> 204 >> 205 #----------------------------------------------------------------------- >> 206 # Include the file listing all the imported targets. >> 207 # (Not needed if used in the same Geant4 project, or if we have run before) >> 208 # This is always installed in the same location as us... >> 209 # >> 210 if(NOT CMAKE_PROJECT_NAME STREQUAL Geant4) >> 211 if(NOT Geant4_LIBDEPS_LOADED) >> 212 include("${_thisdir}/Geant4LibraryDepends.cmake") >> 213 set(Geant4_LIBDEPS_LOADED 1) >> 214 endif() >> 215 endif() 203 216 204 #--------------------------------------------- 217 #----------------------------------------------------------------------- 205 # Data Resources 218 # Data Resources 206 # NB: Because data paths can be "forward decla 219 # NB: Because data paths can be "forward declared" these offer no 207 # guarantee of data existence. They only provi 220 # guarantee of data existence. They only provide a hint. 208 # 221 # 209 set(Geant4_DATASET_DESCRIPTIONS "@GEANT4_DATAS 222 set(Geant4_DATASET_DESCRIPTIONS "@GEANT4_DATASET_DESCRIPTIONS@") 210 223 211 foreach(_g4dataset_tuple ${Geant4_DATASET_DESC 224 foreach(_g4dataset_tuple ${Geant4_DATASET_DESCRIPTIONS}) 212 # Format is NAME|ENVVAR|PATH 225 # Format is NAME|ENVVAR|PATH 213 string(REPLACE "|" ";" _g4dataset_tuple "${_ 226 string(REPLACE "|" ";" _g4dataset_tuple "${_g4dataset_tuple}") 214 list(GET _g4dataset_tuple 0 _g4dataset_name) 227 list(GET _g4dataset_tuple 0 _g4dataset_name) 215 list(APPEND Geant4_DATASETS ${_g4dataset_nam 228 list(APPEND Geant4_DATASETS ${_g4dataset_name}) 216 list(GET _g4dataset_tuple 1 Geant4_DATASET_$ 229 list(GET _g4dataset_tuple 1 Geant4_DATASET_${_g4dataset_name}_ENVVAR) 217 list(GET _g4dataset_tuple 2 Geant4_DATASET_$ 230 list(GET _g4dataset_tuple 2 Geant4_DATASET_${_g4dataset_name}_PATH) 218 endforeach() 231 endforeach() 219 unset(Geant4_DATASET_DESCRIPTIONS) 232 unset(Geant4_DATASET_DESCRIPTIONS) 220 233 221 #--------------------------------------------- 234 #----------------------------------------------------------------------- 222 # Optional Build Components << 235 # Setup components. >> 236 # THIS SECTION IS VERY ROUGH AND VERY MUCH CUT AND PASTE. >> 237 # TODO: INVESTIGATE TIDY UP WITH LESS PROCESSING. 223 #--------------------------------------------- 238 #----------------------------------------------------------------------- 224 # - General Multithreading << 239 # Many components are simply present as parts of libraries or always built >> 240 # but require additional compile definitions. >> 241 # >> 242 # Builtin/External packages >> 243 set(Geant4_builtin_clhep_FOUND @GEANT4_USE_BUILTIN_CLHEP@) >> 244 set(Geant4_builtin_expat_FOUND @GEANT4_USE_BUILTIN_EXPAT@) >> 245 set(Geant4_builtin_zlib_FOUND @GEANT4_USE_BUILTIN_ZLIB@) >> 246 >> 247 # - Multithreading 225 set(Geant4_multithreaded_FOUND @GEANT4_BUILD_M 248 set(Geant4_multithreaded_FOUND @GEANT4_BUILD_MULTITHREADED@) 226 if(Geant4_multithreaded_FOUND) 249 if(Geant4_multithreaded_FOUND) 227 # - Define variable to indicate TLS model us << 250 list(REMOVE_ITEM Geant4_FIND_COMPONENTS multithreaded) 228 set(Geant4_TLS_MODEL "@GEANT4_BUILD_TLS_MODE << 251 list(APPEND Geant4_DEFINITIONS -DG4MULTITHREADED) 229 if(Geant4_TLS_MODEL STREQUAL "auto") << 230 unset(Geant4_TLS_MODEL) << 231 endif() << 232 endif() 252 endif() 233 253 234 # - Smart track stack << 254 # - GDML 235 set(Geant4_smartstack_FOUND @GEANT4_USE_SMARTS << 255 set(Geant4_gdml_FOUND @GEANT4_USE_GDML@) 236 << 256 if(Geant4_gdml_FOUND) 237 # - ParticleHP as HP << 257 list(REMOVE_ITEM Geant4_FIND_COMPONENTS gdml) 238 set(Geant4_php_as_hp_FOUND @GEANT4_BUILD_PHP_A << 258 endif() 239 259 240 # - G3toG4 260 # - G3toG4 241 set(Geant4_g3tog4_FOUND @GEANT4_USE_G3TOG4@) 261 set(Geant4_g3tog4_FOUND @GEANT4_USE_G3TOG4@) 242 if(Geant4_g3tog4_FOUND) 262 if(Geant4_g3tog4_FOUND) 243 if(Geant4_FIND_REQUIRED_g3tog4) 263 if(Geant4_FIND_REQUIRED_g3tog4) 244 set(_geant4_use_g3tog4_library ON) 264 set(_geant4_use_g3tog4_library ON) 245 endif() 265 endif() >> 266 list(REMOVE_ITEM Geant4_FIND_COMPONENTS g3tog4) 246 endif() 267 endif() 247 268 248 #--------------------------------------------- << 269 # - UI : TCSH 249 # Optional Components that may depend on exter << 270 set(Geant4_ui_tcsh_FOUND @UNIX@) 250 #--------------------------------------------- << 271 if(Geant4_ui_tcsh_FOUND) 251 # Optionally import build-time package setting << 272 if(Geant4_FIND_REQUIRED_ui_tcsh OR Geant4_FIND_REQUIRED_ui_all) 252 # for find_package to work with << 273 list(APPEND Geant4_DEFINITIONS -DG4UI_USE_TCSH) 253 include("${CMAKE_CURRENT_LIST_DIR}/Geant4Packa << 254 << 255 # - CLHEP << 256 set(Geant4_system_clhep_FOUND @GEANT4_USE_SYST << 257 if(Geant4_system_clhep_FOUND) << 258 set(Geant4_builtin_clhep_FOUND FALSE) << 259 find_dependency(CLHEP @CLHEP_VERSION@ EXACT << 260 else() << 261 set(Geant4_builtin_clhep_FOUND TRUE) << 262 endif() << 263 << 264 # - EXPAT << 265 set(Geant4_builtin_expat_FOUND @GEANT4_USE_BUI << 266 if(NOT Geant4_builtin_expat_FOUND) << 267 find_dependency(EXPAT @EXPAT_VERSION_STRING@ << 268 include("${CMAKE_CURRENT_LIST_DIR}/G4EXPATSh << 269 endif() << 270 << 271 # - ZLIB << 272 set(Geant4_builtin_zlib_FOUND @GEANT4_USE_BUIL << 273 if(NOT Geant4_builtin_zlib_FOUND) << 274 find_dependency(ZLIB @ZLIB_VERSION_STRING@) << 275 endif() << 276 << 277 # - PTL/TBB << 278 set(Geant4_system_ptl_FOUND @GEANT4_USE_SYSTEM << 279 set(Geant4_TBB_FOUND @GEANT4_USE_TBB@) << 280 if(Geant4_system_ptl_FOUND) << 281 set(Geant4_builtin_ptl_FOUND FALSE) << 282 if(Geant4_TBB_FOUND) << 283 find_dependency(PTL @PTL_VERSION@ COMPONEN << 284 else() << 285 find_dependency(PTL @PTL_VERSION@) << 286 endif() << 287 else() << 288 # We know exactly where PTL is << 289 set(Geant4_builtin_ptl_FOUND TRUE) << 290 if(CMAKE_VERSION VERSION_GREATER 3.8.9999) << 291 find_dependency(PTL NO_DEFAULT_PATH PATHS << 292 else() << 293 find_package(PTL REQUIRED NO_DEFAULT_PATH << 294 endif() 274 endif() >> 275 list(REMOVE_ITEM Geant4_FIND_COMPONENTS ui_tcsh) 295 endif() 276 endif() 296 277 297 # - GDML << 278 # - UI : win32 298 set(Geant4_gdml_FOUND @GEANT4_USE_GDML@) << 279 set(Geant4_ui_win32_FOUND @WIN32@) 299 if(Geant4_gdml_FOUND) << 280 if(Geant4_ui_win32_FOUND) 300 find_dependency(XercesC @XercesC_VERSION@) << 281 if(Geant4_FIND_REQUIRED_ui_win32 OR Geant4_FIND_REQUIRED_ui_all) 301 endif() << 282 list(APPEND 302 << 283 Geant4_DEFINITIONS 303 # - VecGeom << 284 -DG4INTY_USE_WIN32 304 set(Geant4_usolids_FOUND @GEANT4_USE_USOLIDS_E << 285 -DG4UI_USE_WIN32 305 if(Geant4_usolids_FOUND) << 286 ) 306 find_dependency(VecGeom @VecGeom_VERSION@) << 287 endif() 307 endif() << 288 list(REMOVE_ITEM Geant4_FIND_COMPONENTS ui_win32) 308 << 309 # - Freetype << 310 set(Geant4_freetype_FOUND @GEANT4_USE_FREETYPE << 311 if(Geant4_freetype_FOUND) << 312 find_dependency(Freetype @FREETYPE_VERSION_S << 313 include("${CMAKE_CURRENT_LIST_DIR}/G4Freetyp << 314 endif() << 315 << 316 # - HDF5 << 317 set(Geant4_hdf5_FOUND @GEANT4_USE_HDF5@) << 318 if(Geant4_hdf5_FOUND) << 319 find_dependency(HDF5) << 320 include("${CMAKE_CURRENT_LIST_DIR}/G4HDF5Shi << 321 endif() 289 endif() 322 290 323 #--------------------------------------------- << 291 # - Visualization : Network DAWN 324 # UI/VIS << 292 set(Geant4_vis_dawn_network_FOUND @GEANT4_USE_NETWORK_DAWN@) 325 # << 293 if(Geant4_vis_dawn_network_FOUND) 326 # Prefer Legacy GL when using CMake >= 3.10 << 294 if(Geant4_FIND_REQUIRED_vis_dawn_network OR Geant4_FIND_REQUIRED_vis_all) 327 set(OpenGL_GL_PREFERENCE_SAVE "${OpenGL_GL_PRE << 295 list(APPEND Geant4_DEFINITIONS -DG4VIS_USE_DAWN) 328 set(OpenGL_GL_PREFERENCE "LEGACY") << 296 endif() 329 << 297 list(REMOVE_ITEM Geant4_FIND_COMPONENTS vis_dawn_network) 330 # - Helper variables for ui/vis_all components << 331 if("ui_all" IN_LIST Geant4_FIND_COMPONENTS) << 332 set(Geant4_ui_all_FOUND TRUE) << 333 endif() 298 endif() 334 299 335 if("vis_all" IN_LIST Geant4_FIND_COMPONENTS) << 300 # - Visualization : Network VRML 336 set(Geant4_vis_all_FOUND TRUE) << 301 set(Geant4_vis_vrml_network_FOUND @GEANT4_USE_NETWORK_VRML@) >> 302 if(Geant4_vis_vrml_network_FOUND) >> 303 if(Geant4_FIND_REQUIRED_vis_vrml_network OR Geant4_FIND_REQUIRED_vis_all) >> 304 list(APPEND Geant4_DEFINITIONS -DG4VIS_USE_VRML) >> 305 endif() >> 306 list(REMOVE_ITEM Geant4_FIND_COMPONENTS vis_vrml_network) 337 endif() 307 endif() 338 308 339 # - UI : TCSH << 340 set(Geant4_ui_tcsh_FOUND @UNIX@) << 341 << 342 # - UI : win32 << 343 set(Geant4_ui_win32_FOUND @WIN32@) << 344 << 345 #--------------------------------------------- 309 #----------------------------------------------------------------------- 346 # Components which requires slightly more comp 310 # Components which requires slightly more complex setup 347 # 311 # 348 # - Visualization : RayTracerX 312 # - Visualization : RayTracerX 349 set(Geant4_vis_raytracer_x11_FOUND @GEANT4_USE 313 set(Geant4_vis_raytracer_x11_FOUND @GEANT4_USE_RAYTRACER_X11@) 350 if(Geant4_vis_raytracer_x11_FOUND) 314 if(Geant4_vis_raytracer_x11_FOUND) 351 find_dependency(X11) << 315 if(Geant4_FIND_REQUIRED_vis_raytracer_x11 OR Geant4_FIND_REQUIRED_vis_all) 352 include("${CMAKE_CURRENT_LIST_DIR}/G4X11Shim << 316 list(APPEND >> 317 Geant4_DEFINITIONS >> 318 -DG4INTY_USE_XT >> 319 -DG4VIS_USE_RAYTRACERX >> 320 ) >> 321 endif() >> 322 list(REMOVE_ITEM Geant4_FIND_COMPONENTS vis_raytracer_x11) 353 endif() 323 endif() 354 324 355 # - Qt (UI and Vis!) 325 # - Qt (UI and Vis!) 356 set(Geant4_qt_FOUND @GEANT4_USE_QT@) 326 set(Geant4_qt_FOUND @GEANT4_USE_QT@) 357 set(Geant4_qt3d_FOUND @GEANT4_USE_QT3D@) << 327 set(Geant4_USES_QT5 @Qt5Core_FOUND@) 358 if(Geant4_qt_FOUND) 328 if(Geant4_qt_FOUND) 359 # Must always refind Qt to recreate imported << 329 if(Geant4_FIND_REQUIRED_qt OR Geant4_FIND_REQUIRED_ui_all OR 360 # are in the public interface, always need l << 330 Geant4_FIND_REQUIRED_vis_all) 361 find_dependency(Qt@QT_VERSION_MAJOR@Core REQ << 331 # If we have Qt5, we need to refind the components because they use 362 find_dependency(Qt@QT_VERSION_MAJOR@Gui REQU << 332 # imported targets, so linking will not work unless we recreate 363 find_dependency(Qt@QT_VERSION_MAJOR@Widgets << 333 # them 364 find_dependency(Qt@QT_VERSION_MAJOR@OpenGL R << 334 if(Geant4_USES_QT5) 365 if(@QT_VERSION_MAJOR@ GREATER 5) << 335 find_package(Qt5Core REQUIRED PATHS "@Qt5Core_DIR@") 366 find_dependency(Qt@QT_VERSION_MAJOR@OpenGL << 336 find_package(Qt5Gui REQUIRED PATHS "@Qt5Gui_DIR@") 367 endif() << 337 find_package(Qt5Widgets REQUIRED PATHS "@Qt5Widgets_DIR@") 368 << 338 find_package(Qt5OpenGL REQUIRED PATHS "@Qt5OpenGL_DIR@") 369 if(Geant4_qt3d_FOUND) << 339 find_package(Qt5PrintSupport REQUIRED PATHS "@Qt5PrintSupport_DIR@") 370 find_dependency(Qt@QT_VERSION_MAJOR@3DCore << 340 endif() 371 find_dependency(Qt@QT_VERSION_MAJOR@3DExtr << 341 372 find_dependency(Qt@QT_VERSION_MAJOR@3DRend << 342 list(APPEND 373 endif() << 343 Geant4_DEFINITIONS 374 << 344 -DG4INTY_USE_QT 375 # Also require OpenGL << 345 -DG4UI_USE_QT 376 find_dependency(OpenGL) << 346 -DG4VIS_USE_OPENGLQT 377 << 347 ) 378 # Qt must be activated both directly and for << 379 if(("qt" IN_LIST Geant4_FIND_COMPONENTS) << 380 OR ("vis_openinventor" IN_LIST Geant4_FIN << 381 OR Geant4_ui_all_FOUND OR Geant4_vis_all_ << 382 set(_geant4_use_opengl_library ON) 348 set(_geant4_use_opengl_library ON) 383 # Qt3D is always on if available << 384 set(_geant4_use_qt3D_library ${Geant4_qt3d << 385 endif() 349 endif() >> 350 list(REMOVE_ITEM Geant4_FIND_COMPONENTS qt) >> 351 endif() >> 352 >> 353 # - Wt (UI and Vis!) >> 354 set(Geant4_wt_FOUND @GEANT4_USE_WT@) >> 355 if(Geant4_wt_FOUND) >> 356 if(Geant4_FIND_REQUIRED_wt OR Geant4_FIND_REQUIRED_ui_all OR >> 357 Geant4_FIND_REQUIRED_vis_all) >> 358 list(APPEND >> 359 Geant4_DEFINITIONS >> 360 -DG4INTY_USE_WT >> 361 -DG4UI_USE_WT >> 362 -DG4VIS_USE_OPENGLWT >> 363 ) >> 364 set(_geant4_use_opengl_library ON) >> 365 endif() >> 366 list(REMOVE_ITEM Geant4_FIND_COMPONENTS wt) 386 endif() 367 endif() 387 368 388 # - Motif (UI and Vis!) 369 # - Motif (UI and Vis!) 389 set(Geant4_motif_FOUND @GEANT4_USE_XM@) 370 set(Geant4_motif_FOUND @GEANT4_USE_XM@) 390 if(Geant4_motif_FOUND) 371 if(Geant4_motif_FOUND) 391 find_dependency(X11) << 372 if(Geant4_FIND_REQUIRED_motif OR Geant4_FIND_REQUIRED_ui_all OR 392 include("${CMAKE_CURRENT_LIST_DIR}/G4X11Shim << 373 Geant4_FIND_REQUIRED_vis_all) 393 find_dependency(Motif) << 374 list(APPEND 394 include("${CMAKE_CURRENT_LIST_DIR}/G4MotifSh << 375 Geant4_DEFINITIONS 395 if(APPLE) << 376 -DG4INTY_USE_XT 396 find_dependency(XQuartzGL) << 377 -DG4UI_USE_XM 397 else() << 378 -DG4VIS_USE_OPENGLXM 398 find_dependency(OpenGL) << 379 ) 399 endif() << 400 << 401 # Motif can be activated both directly and f << 402 if(("motif" IN_LIST Geant4_FIND_COMPONENTS) << 403 OR ("vis_openinventor" IN_LIST Geant4_FIN << 404 OR Geant4_ui_all_FOUND OR Geant4_vis_all_ << 405 set(_geant4_use_opengl_library ON) 380 set(_geant4_use_opengl_library ON) 406 endif() 381 endif() >> 382 >> 383 list(REMOVE_ITEM Geant4_FIND_COMPONENTS motif) 407 endif() 384 endif() 408 385 409 # - OpenGL X11 386 # - OpenGL X11 410 set(Geant4_vis_opengl_x11_FOUND @GEANT4_USE_OP 387 set(Geant4_vis_opengl_x11_FOUND @GEANT4_USE_OPENGL_X11@) 411 if(Geant4_vis_opengl_x11_FOUND) 388 if(Geant4_vis_opengl_x11_FOUND) 412 find_dependency(X11) << 389 if(Geant4_FIND_REQUIRED_vis_opengl_x11 OR Geant4_FIND_REQUIRED_vis_all) 413 include("${CMAKE_CURRENT_LIST_DIR}/G4X11Shim << 390 list(APPEND 414 if(APPLE) << 391 Geant4_DEFINITIONS 415 find_dependency(XQuartzGL) << 392 -DG4INTY_USE_XT 416 else() << 393 -DG4VIS_USE_OPENGLX 417 find_dependency(OpenGL) << 394 ) 418 endif() << 419 << 420 if(("vis_opengl_x11" IN_LIST Geant4_FIND_COM << 421 set(_geant4_use_opengl_library ON) 395 set(_geant4_use_opengl_library ON) 422 endif() 396 endif() >> 397 >> 398 list(REMOVE_ITEM Geant4_FIND_COMPONENTS vis_opengl_x11) 423 endif() 399 endif() 424 400 425 # - OpenGL Win32 401 # - OpenGL Win32 426 set(Geant4_vis_opengl_win32_FOUND @GEANT4_USE_ 402 set(Geant4_vis_opengl_win32_FOUND @GEANT4_USE_OPENGL_WIN32@) 427 if(Geant4_vis_opengl_win32_FOUND) 403 if(Geant4_vis_opengl_win32_FOUND) 428 find_dependency(OpenGL) << 404 if(Geant4_FIND_REQUIRED_vis_opengl_win32 OR Geant4_FIND_REQUIRED_vis_all) 429 if(("vis_opengl_win32" IN_LIST Geant4_FIND_C << 405 list(APPEND >> 406 Geant4_DEFINITIONS >> 407 -DG4INTY_USE_WIN32 >> 408 -DG4VIS_USE_OPENGLWIN32 >> 409 ) 430 set(_geant4_use_opengl_library ON) 410 set(_geant4_use_opengl_library ON) 431 endif() 411 endif() >> 412 >> 413 list(REMOVE_ITEM Geant4_FIND_COMPONENTS vis_opengl_win32) 432 endif() 414 endif() 433 415 434 # - OpenInventor 416 # - OpenInventor 435 set(Geant4_vis_openinventor_FOUND @GEANT4_USE_ 417 set(Geant4_vis_openinventor_FOUND @GEANT4_USE_INVENTOR@) 436 set(Geant4_vis_openinventor_qt_FOUND @GEANT4_U << 437 if(Geant4_vis_openinventor_FOUND) 418 if(Geant4_vis_openinventor_FOUND) 438 find_dependency(Coin) << 419 if(Geant4_FIND_REQUIRED_vis_openinventor OR Geant4_FIND_REQUIRED_vis_all) 439 << 420 if(UNIX AND NOT WIN32) 440 if(Geant4_vis_openinventor_qt_FOUND) << 421 list(APPEND Geant4_DEFINITIONS 441 # Qt dependency handled by Geant4_vis_qt_F << 422 -DG4INTY_USE_XT 442 # always ON if Inventor_QT is << 423 -DG4VIS_USE_OI 443 find_dependency(SoQt) << 424 -DG4VIS_USE_OIX 444 else() << 425 ) 445 if(WIN32) << 426 elseif(WIN32) 446 find_dependency(SoWin) << 427 list(APPEND Geant4_DEFINITIONS 447 else() << 428 -G4INTY_USE_WIN32 448 # Motif/X11/GL dependency handled by Gea << 429 -DG4VIS_USE_OI 449 # always ON if Inventor/Xt is. << 430 -DG4VIS_USE_OIWIN32 450 find_dependency(SoXt) << 431 ) 451 endif() 432 endif() 452 endif() << 453 433 454 if(("vis_openinventor" IN_LIST Geant4_FIND_C << 455 set(_geant4_use_inventor_library ON) 434 set(_geant4_use_inventor_library ON) 456 endif() 435 endif() 457 endif() << 458 << 459 # Reset any OpenGL Preference << 460 set(OpenGL_GL_PREFERENCE "${OpenGL_GL_PREFEREN << 461 436 462 set(Geant4_vis_Vtk_FOUND @GEANT4_USE_VTK@) << 437 list(REMOVE_ITEM Geant4_FIND_COMPONENTS vis_openinventor) 463 if(Geant4_vis_Vtk_FOUND) << 464 find_dependency(VTK 9 REQUIRED COMPONENTS << 465 CommonColor << 466 InteractionStyle << 467 IOExport << 468 GUISupportQt << 469 RenderingVolumeOpenGL2 << 470 ) << 471 set(_geant4_use_vtk_library ON) << 472 endif() 438 endif() 473 439 474 #--------------------------------------------- << 475 # Include the files listing all the imported t << 476 # Intel/MSVC Compile Features << 477 # (Not needed if used in the same Geant4 proje << 478 # This is always installed in the same locatio << 479 # << 480 if(NOT CMAKE_PROJECT_NAME STREQUAL Geant4) << 481 include("${_geant4_thisdir}/Modules/IntelCom << 482 include("${_geant4_thisdir}/Modules/MSVCComp << 483 << 484 if(NOT Geant4_LIBDEPS_LOADED) << 485 include("${_geant4_thisdir}/Geant4LibraryD << 486 set(Geant4_LIBDEPS_LOADED 1) << 487 endif() << 488 endif() << 489 440 490 #--------------------------------------------- 441 #----------------------------------------------------------------------- 491 # Now perform final configuration of libraries 442 # Now perform final configuration of libraries... 492 # We provide FOUND variables for presence of s << 443 # We provide FOUND variables for shared and static but for now we don't 493 # User can supply "static" component to force << 444 # allow users to choose - we prefer shared if available, and fallback to 494 # available. << 445 # static otherwise >> 446 # 495 set(Geant4_shared_FOUND @BUILD_SHARED_LIBS@) 447 set(Geant4_shared_FOUND @BUILD_SHARED_LIBS@) 496 set(Geant4_static_FOUND @BUILD_STATIC_LIBS@) 448 set(Geant4_static_FOUND @BUILD_STATIC_LIBS@) 497 449 498 # - Default setting : shared if available, sta << 499 if(Geant4_shared_FOUND) 450 if(Geant4_shared_FOUND) 500 set(_geant4_lib_use_suffix "") 451 set(_geant4_lib_use_suffix "") 501 else() 452 else() 502 set(_geant4_lib_use_suffix "-static") 453 set(_geant4_lib_use_suffix "-static") 503 endif() 454 endif() 504 455 505 if(("static" IN_LIST Geant4_FIND_COMPONENTS) A << 506 set(_geant4_lib_use_suffix "-static") << 507 endif() << 508 << 509 # The list of libraries probably should be aut 456 # The list of libraries probably should be autogenerated, but we hard code 510 # for now. We don't have to divide the list of 457 # for now. We don't have to divide the list of shared libraries, but we 511 # do so for consistency with the way we'll nee 458 # do so for consistency with the way we'll need to do it for static. 512 # - Always on Vis Components 459 # - Always on Vis Components 513 set(_geant4_internal_libraries 460 set(_geant4_internal_libraries 514 Geant4::G4Tree${_geant4_lib_use_suffix} << 461 G4Tree${_geant4_lib_use_suffix} 515 Geant4::G4FR${_geant4_lib_use_suffix} << 462 G4FR${_geant4_lib_use_suffix} 516 Geant4::G4GMocren${_geant4_lib_use_suffix} << 463 G4GMocren${_geant4_lib_use_suffix} 517 Geant4::G4visHepRep${_geant4_lib_use_suffix} << 464 G4visHepRep${_geant4_lib_use_suffix} 518 Geant4::G4RayTracer${_geant4_lib_use_suffix} << 465 G4RayTracer${_geant4_lib_use_suffix} 519 Geant4::G4VRML${_geant4_lib_use_suffix} << 466 G4VRML${_geant4_lib_use_suffix} 520 Geant4::G4ToolsSG${_geant4_lib_use_suffix}) << 467 ) 521 468 522 # - G4OpenGL if it's requested. 469 # - G4OpenGL if it's requested. 523 if(_geant4_use_opengl_library) 470 if(_geant4_use_opengl_library) 524 list(APPEND _geant4_internal_libraries Geant << 471 list(APPEND _geant4_internal_libraries 525 endif() << 472 G4OpenGL${_geant4_lib_use_suffix} 526 << 473 G4gl2ps${_geant4_lib_use_suffix} 527 # - Qt3D if it's requested. << 474 ) 528 if(_geant4_use_qt3D_library) << 475 list(APPEND Geant4_DEFINITIONS -DG4VIS_USE_OPENGL) 529 list(APPEND _geant4_internal_libraries Geant << 530 endif() 476 endif() 531 477 532 # - G4OpenInventor if it's requested. 478 # - G4OpenInventor if it's requested. 533 if(_geant4_use_inventor_library) 479 if(_geant4_use_inventor_library) 534 list(APPEND _geant4_internal_libraries Geant << 480 list(APPEND _geant4_internal_libraries 535 endif() << 481 G4OpenInventor${_geant4_lib_use_suffix} 536 << 482 ) 537 if(_geant4_use_vtk_library) << 538 list(APPEND _geant4_internal_libraries Geant << 539 endif() << 540 << 541 # - GDML always added for now as old G4persist << 542 if(Geant4_gdml_FOUND) << 543 set(_geant4_g4gdml_library Geant4::G4gdml${_ << 544 endif() 483 endif() 545 484 546 # - G3toG4 if it's requested 485 # - G3toG4 if it's requested 547 if(_geant4_use_g3tog4_library) 486 if(_geant4_use_g3tog4_library) 548 set(_geant4_g3tog4_library Geant4::G3toG4${_ << 487 set(_geant4_g3tog4_library G3toG4${_geant4_lib_use_suffix}) 549 endif() 488 endif() 550 489 551 set(_geant4_physicslists_library Geant4::G4phy << 552 << 553 # - 'Kernel' libraries 490 # - 'Kernel' libraries 554 list(APPEND _geant4_internal_libraries 491 list(APPEND _geant4_internal_libraries 555 Geant4::G4vis_management${_geant4_lib_use_su << 492 G4vis_management${_geant4_lib_use_suffix} 556 Geant4::G4modeling${_geant4_lib_use_suffix} << 493 G4modeling${_geant4_lib_use_suffix} 557 Geant4::G4interfaces${_geant4_lib_use_suffix << 494 G4interfaces${_geant4_lib_use_suffix} 558 Geant4::G4mctruth${_geant4_lib_use_suffix} << 495 G4persistency${_geant4_lib_use_suffix} 559 Geant4::G4geomtext${_geant4_lib_use_suffix} << 560 ${_geant4_g4gdml_library} << 561 ${_geant4_g3tog4_library} 496 ${_geant4_g3tog4_library} 562 Geant4::G4analysis${_geant4_lib_use_suffix} << 497 G4analysis${_geant4_lib_use_suffix} 563 Geant4::G4error_propagation${_geant4_lib_use << 498 G4error_propagation${_geant4_lib_use_suffix} 564 Geant4::G4readout${_geant4_lib_use_suffix} << 499 G4readout${_geant4_lib_use_suffix} 565 ${_geant4_physicslists_library} << 500 G4physicslists${_geant4_lib_use_suffix} 566 Geant4::G4run${_geant4_lib_use_suffix} << 501 G4run${_geant4_lib_use_suffix} 567 Geant4::G4event${_geant4_lib_use_suffix} << 502 G4event${_geant4_lib_use_suffix} 568 Geant4::G4tracking${_geant4_lib_use_suffix} << 503 G4tracking${_geant4_lib_use_suffix} 569 Geant4::G4parmodels${_geant4_lib_use_suffix} << 504 G4parmodels${_geant4_lib_use_suffix} 570 Geant4::G4processes${_geant4_lib_use_suffix} << 505 G4processes${_geant4_lib_use_suffix} 571 Geant4::G4digits_hits${_geant4_lib_use_suffi << 506 G4digits_hits${_geant4_lib_use_suffix} 572 Geant4::G4track${_geant4_lib_use_suffix} << 507 G4track${_geant4_lib_use_suffix} 573 Geant4::G4particles${_geant4_lib_use_suffix} << 508 G4particles${_geant4_lib_use_suffix} 574 Geant4::G4geometry${_geant4_lib_use_suffix} << 509 G4geometry${_geant4_lib_use_suffix} 575 Geant4::G4materials${_geant4_lib_use_suffix} << 510 G4materials${_geant4_lib_use_suffix} 576 Geant4::G4graphics_reps${_geant4_lib_use_suf << 511 G4graphics_reps${_geant4_lib_use_suffix} 577 Geant4::G4intercoms${_geant4_lib_use_suffix} << 512 G4intercoms${_geant4_lib_use_suffix} 578 Geant4::G4global${_geant4_lib_use_suffix} << 513 G4global${_geant4_lib_use_suffix} 579 # G4tools is INTERFACE, so same for both sta << 580 Geant4::G4tools << 581 ) 514 ) 582 515 583 # - Any externals built by Geant4 516 # - Any externals built by Geant4 584 foreach(_extlib @GEANT4_EXTERNALS_TARGETS@) 517 foreach(_extlib @GEANT4_EXTERNALS_TARGETS@) 585 list(APPEND 518 list(APPEND 586 _geant4_internal_libraries 519 _geant4_internal_libraries 587 Geant4::${_extlib}${_geant4_lib_use_suffix << 520 ${_extlib}${_geant4_lib_use_suffix} 588 ) 521 ) 589 endforeach() 522 endforeach() 590 523 591 # - Now set them to Geant4_LIBRARIES 524 # - Now set them to Geant4_LIBRARIES 592 set(Geant4_LIBRARIES ${_geant4_internal_librar 525 set(Geant4_LIBRARIES ${_geant4_internal_libraries}) 593 526 594 #--------------------------------------------- 527 #----------------------------------------------------------------------- 595 # Remove any duplicates from the Geant4_{INCLU << 528 # Remove any duplicates from the Geant4_{DEFINITIONS,INCLUDE_DIRS,LIBRARIES} 596 # variables so that multiple passes append thi 529 # variables so that multiple passes append things correctly 597 # 530 # 598 if(Geant4_INCLUDE_DIRS) << 531 list(REMOVE_DUPLICATES Geant4_DEFINITIONS) 599 list(REMOVE_DUPLICATES Geant4_INCLUDE_DIRS) << 532 list(REMOVE_DUPLICATES Geant4_INCLUDE_DIRS) 600 endif() << 533 list(REMOVE_DUPLICATES Geant4_LIBRARIES) 601 << 602 if(Geant4_LIBRARIES) << 603 list(REMOVE_DUPLICATES Geant4_LIBRARIES) << 604 endif() << 605 534 606 #--------------------------------------------- 535 #----------------------------------------------------------------------- 607 # Point the user to the UseGeant4.cmake file w 536 # Point the user to the UseGeant4.cmake file which they may wish to include 608 # to help them with setting up Geant4 537 # to help them with setting up Geant4 609 # 538 # 610 set(Geant4_USE_FILE "${_geant4_thisdir}/UseGea << 539 set(Geant4_USE_FILE ${_thisdir}/UseGeant4.cmake) 611 540 612 #--------------------------------------------- 541 #----------------------------------------------------------------------- 613 # Pop our custom module path from the CMake on << 542 # Finally, handle any remaining components. 614 list(REMOVE_AT CMAKE_MODULE_PATH 0) << 543 # We should have dealt with all available components above, except for >> 544 # ui_all and vis_all, and removed them from the list of FIND_COMPONENTS >> 545 # so any left we either didn't find or don't know about. Emit a warning >> 546 # if REQUIRED isn't set, or FATAL_ERROR otherwise >> 547 # >> 548 list(REMOVE_DUPLICATES Geant4_FIND_COMPONENTS) >> 549 list(REMOVE_ITEM Geant4_FIND_COMPONENTS ui_all vis_all) 615 550 616 #--------------------------------------------- << 551 foreach(_remaining ${Geant4_FIND_COMPONENTS}) 617 # Check FOUNDness of required components. << 552 if(Geant4_FIND_REQUIRED) 618 foreach(_comp ${Geant4_FIND_COMPONENTS}) << 553 message(FATAL_ERROR "Geant4 component ${_remaining} not found") 619 if(NOT Geant4_${_comp}_FOUND) << 554 elseif(NOT Geant4_FIND_QUIETLY) 620 if(Geant4_FIND_REQUIRED_${_comp}) << 555 message(WARNING " Geant4 component ${_remaining} not found") 621 message(WARNING "Geant4 required compone << 622 set(Geant4_FOUND FALSE) << 623 endif() << 624 endif() 556 endif() >> 557 unset(Geant4_FIND_REQUIRED_${_remaining}) 625 endforeach() 558 endforeach() 626 559 627 #--------------------------------------------- << 560 # And we should be done... 628 # Reporting via FindPackageHandleStandardArgs << 561 629 include(FindPackageHandleStandardArgs) << 630 set(${CMAKE_FIND_PACKAGE_NAME}_CONFIG "${CMAKE << 631 find_package_handle_standard_args(@PROJECT_NAM <<