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