| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // class G4GeometryMessenger implementation <<
27 // 26 //
28 // Author: G.Cosmo, CERN << 27 //
>> 28 // --------------------------------------------------------------------
>> 29 // GEANT 4 class source file
>> 30 //
>> 31 // G4GeometryMessenger
>> 32 //
>> 33 // Author: G.Cosmo, CERN.
>> 34 //
29 // ------------------------------------------- 35 // --------------------------------------------------------------------
30 36
31 #include <iomanip> 37 #include <iomanip>
32 38
33 #include "G4GeometryMessenger.hh" 39 #include "G4GeometryMessenger.hh"
34 40
35 #include "G4TransportationManager.hh" 41 #include "G4TransportationManager.hh"
36 #include "G4GeometryManager.hh" 42 #include "G4GeometryManager.hh"
37 #include "G4VPhysicalVolume.hh" 43 #include "G4VPhysicalVolume.hh"
38 #include "G4Navigator.hh" 44 #include "G4Navigator.hh"
39 #include "G4PropagatorInField.hh" <<
40 45
41 #include "G4UIdirectory.hh" 46 #include "G4UIdirectory.hh"
42 #include "G4UIcommand.hh" 47 #include "G4UIcommand.hh"
43 #include "G4UIcmdWithoutParameter.hh" 48 #include "G4UIcmdWithoutParameter.hh"
44 #include "G4UIcmdWithABool.hh" 49 #include "G4UIcmdWithABool.hh"
45 #include "G4UIcmdWithAnInteger.hh" 50 #include "G4UIcmdWithAnInteger.hh"
46 #include "G4UIcmdWithADoubleAndUnit.hh" 51 #include "G4UIcmdWithADoubleAndUnit.hh"
47 52
48 #include "G4GeomTestVolume.hh" 53 #include "G4GeomTestVolume.hh"
49 54
50 // 55 //
51 // Constructor 56 // Constructor
52 // 57 //
53 G4GeometryMessenger::G4GeometryMessenger(G4Tra 58 G4GeometryMessenger::G4GeometryMessenger(G4TransportationManager* tman)
54 : tmanager(tman) << 59 : tol(0.0), recLevel(0), recDepth(-1), tmanager(tman), tvolume(0)
55 { 60 {
56 geodir = new G4UIdirectory( "/geometry/" ); 61 geodir = new G4UIdirectory( "/geometry/" );
57 geodir->SetGuidance( "Geometry control comma 62 geodir->SetGuidance( "Geometry control commands." );
58 63
59 // 64 //
60 // Geometry navigator commands 65 // Geometry navigator commands
61 // 66 //
62 navdir = new G4UIdirectory( "/geometry/navig 67 navdir = new G4UIdirectory( "/geometry/navigator/" );
63 navdir->SetGuidance( "Geometry navigator con 68 navdir->SetGuidance( "Geometry navigator control setup." );
64 69
65 resCmd = new G4UIcmdWithoutParameter( "/geom 70 resCmd = new G4UIcmdWithoutParameter( "/geometry/navigator/reset", this );
66 resCmd->SetGuidance( "Reset navigator and na 71 resCmd->SetGuidance( "Reset navigator and navigation history." );
67 resCmd->SetGuidance( "NOTE: must be called o 72 resCmd->SetGuidance( "NOTE: must be called only after kernel has been" );
68 resCmd->SetGuidance( " initialized once 73 resCmd->SetGuidance( " initialized once through the run manager!" );
69 resCmd->AvailableForStates(G4State_Idle); 74 resCmd->AvailableForStates(G4State_Idle);
70 75
71 verbCmd = new G4UIcmdWithAnInteger( "/geomet 76 verbCmd = new G4UIcmdWithAnInteger( "/geometry/navigator/verbose", this );
72 verbCmd->SetGuidance( "Set run-time verbosit 77 verbCmd->SetGuidance( "Set run-time verbosity for the navigator." );
73 verbCmd->SetGuidance(" 0 : Silent (default)" 78 verbCmd->SetGuidance(" 0 : Silent (default)");
74 verbCmd->SetGuidance(" 1 : Display volume po 79 verbCmd->SetGuidance(" 1 : Display volume positioning and step lengths");
75 verbCmd->SetGuidance(" 2 : Display step/safe 80 verbCmd->SetGuidance(" 2 : Display step/safety info on point location");
76 verbCmd->SetGuidance(" 3 : Display minimal s 81 verbCmd->SetGuidance(" 3 : Display minimal state at -every- step");
77 verbCmd->SetGuidance(" 4 : Maximum verbosity 82 verbCmd->SetGuidance(" 4 : Maximum verbosity (very detailed!)");
78 verbCmd->SetGuidance( "NOTE: this command ha 83 verbCmd->SetGuidance( "NOTE: this command has effect -only- if Geant4 has" );
79 verbCmd->SetGuidance( " been installed 84 verbCmd->SetGuidance( " been installed with the G4VERBOSE flag set!" );
80 verbCmd->SetParameterName("level",true); 85 verbCmd->SetParameterName("level",true);
81 verbCmd->SetDefaultValue(0); 86 verbCmd->SetDefaultValue(0);
82 verbCmd->SetRange("level >=0 && level <=4"); 87 verbCmd->SetRange("level >=0 && level <=4");
83 88
84 chkCmd = new G4UIcmdWithABool( "/geometry/na 89 chkCmd = new G4UIcmdWithABool( "/geometry/navigator/check_mode", this );
85 chkCmd->SetGuidance( "Set navigator in -chec 90 chkCmd->SetGuidance( "Set navigator in -check_mode- state." );
86 chkCmd->SetGuidance( "This will cause extra 91 chkCmd->SetGuidance( "This will cause extra checks to be applied during" );
87 chkCmd->SetGuidance( "navigation. More stric 92 chkCmd->SetGuidance( "navigation. More strict and less tolerant conditions" );
88 chkCmd->SetGuidance( "are applied. A run-tim 93 chkCmd->SetGuidance( "are applied. A run-time performance penalty may be" );
89 chkCmd->SetGuidance( "observed when the -che 94 chkCmd->SetGuidance( "observed when the -check_mode- state is activated." );
90 chkCmd->SetGuidance( "NOTE: this command has 95 chkCmd->SetGuidance( "NOTE: this command has effect -only- if Geant4 has" );
91 chkCmd->SetGuidance( " been installed w 96 chkCmd->SetGuidance( " been installed with the G4VERBOSE flag set!" );
92 chkCmd->SetParameterName("checkFlag",true); 97 chkCmd->SetParameterName("checkFlag",true);
93 chkCmd->SetDefaultValue(false); 98 chkCmd->SetDefaultValue(false);
94 chkCmd->AvailableForStates(G4State_Idle); 99 chkCmd->AvailableForStates(G4State_Idle);
95 100
96 pchkCmd = new G4UIcmdWithABool( "/geometry/n 101 pchkCmd = new G4UIcmdWithABool( "/geometry/navigator/push_notify", this );
97 pchkCmd->SetGuidance( "Set navigator verbosi 102 pchkCmd->SetGuidance( "Set navigator verbosity push notifications." );
98 pchkCmd->SetGuidance( "This allows one to di << 103 pchkCmd->SetGuidance( "This allows to disable/re-enable verbosity in" );
99 pchkCmd->SetGuidance( "navigation, when trac 104 pchkCmd->SetGuidance( "navigation, when tracks may get stuck and require" );
100 pchkCmd->SetGuidance( "one artificial push a 105 pchkCmd->SetGuidance( "one artificial push along the direction by the" );
101 pchkCmd->SetGuidance( "navigator. Notificati 106 pchkCmd->SetGuidance( "navigator. Notification is active by default." );
102 pchkCmd->SetGuidance( "NOTE: this command ha 107 pchkCmd->SetGuidance( "NOTE: this command has effect -only- if Geant4 has" );
103 pchkCmd->SetGuidance( " been installed 108 pchkCmd->SetGuidance( " been installed with the G4VERBOSE flag set!" );
104 pchkCmd->SetParameterName("pushFlag",true); 109 pchkCmd->SetParameterName("pushFlag",true);
105 pchkCmd->SetDefaultValue(true); 110 pchkCmd->SetDefaultValue(true);
106 pchkCmd->AvailableForStates(G4State_Idle); 111 pchkCmd->AvailableForStates(G4State_Idle);
107 112
108 // 113 //
109 // Geometry verification test commands 114 // Geometry verification test commands
110 // 115 //
111 testdir = new G4UIdirectory( "/geometry/test 116 testdir = new G4UIdirectory( "/geometry/test/" );
112 testdir->SetGuidance( "Geometry verification 117 testdir->SetGuidance( "Geometry verification control setup." );
113 testdir->SetGuidance( "Helps in detecting po 118 testdir->SetGuidance( "Helps in detecting possible overlapping regions." );
114 119
115 tolCmd = new G4UIcmdWithADoubleAndUnit( "/ge 120 tolCmd = new G4UIcmdWithADoubleAndUnit( "/geometry/test/tolerance",this );
116 tolCmd->SetGuidance( "Define tolerance (in m 121 tolCmd->SetGuidance( "Define tolerance (in mm) by which overlaps reports" );
117 tolCmd->SetGuidance( "should be reported. By 122 tolCmd->SetGuidance( "should be reported. By default, all overlaps are" );
118 tolCmd->SetGuidance( "reported, i.e. toleran 123 tolCmd->SetGuidance( "reported, i.e. tolerance is set to: 0*mm." );
119 tolCmd->SetParameterName( "Tolerance", true, 124 tolCmd->SetParameterName( "Tolerance", true, true );
120 tolCmd->SetDefaultValue( 0 ); 125 tolCmd->SetDefaultValue( 0 );
121 tolCmd->SetDefaultUnit( "mm" ); 126 tolCmd->SetDefaultUnit( "mm" );
122 tolCmd->SetUnitCategory( "Length" ); 127 tolCmd->SetUnitCategory( "Length" );
123 128
124 verCmd = new G4UIcmdWithABool( "/geometry/te 129 verCmd = new G4UIcmdWithABool( "/geometry/test/verbosity", this );
125 verCmd->SetGuidance( "Specify if running in 130 verCmd->SetGuidance( "Specify if running in verbosity mode or not." );
126 verCmd->SetGuidance( "By default verbosity i 131 verCmd->SetGuidance( "By default verbosity is set to ON (TRUE)." );
127 verCmd->SetParameterName("verbosity",true); 132 verCmd->SetParameterName("verbosity",true);
128 verCmd->SetDefaultValue(true); 133 verCmd->SetDefaultValue(true);
129 verCmd->AvailableForStates(G4State_Idle); 134 verCmd->AvailableForStates(G4State_Idle);
130 135
131 rslCmd = new G4UIcmdWithAnInteger( "/geometr 136 rslCmd = new G4UIcmdWithAnInteger( "/geometry/test/resolution", this );
132 rslCmd->SetGuidance( "Set the number of poin 137 rslCmd->SetGuidance( "Set the number of points on surface to be generated for" );
133 rslCmd->SetGuidance( "checking overlaps." ); 138 rslCmd->SetGuidance( "checking overlaps." );
134 rslCmd->SetParameterName("resolution",true); 139 rslCmd->SetParameterName("resolution",true);
135 rslCmd->SetDefaultValue(10000); 140 rslCmd->SetDefaultValue(10000);
136 141
137 rcsCmd = new G4UIcmdWithAnInteger( "/geometr 142 rcsCmd = new G4UIcmdWithAnInteger( "/geometry/test/recursion_start", this );
138 rcsCmd->SetGuidance( "Set the initial level 143 rcsCmd->SetGuidance( "Set the initial level in the geometry tree for recursion." );
139 rcsCmd->SetGuidance( "recursive_test will th 144 rcsCmd->SetGuidance( "recursive_test will then start from the specified level." );
140 rcsCmd->SetParameterName("initial_level",tru 145 rcsCmd->SetParameterName("initial_level",true);
141 rcsCmd->SetDefaultValue(0); 146 rcsCmd->SetDefaultValue(0);
142 147
143 rcdCmd = new G4UIcmdWithAnInteger( "/geometr 148 rcdCmd = new G4UIcmdWithAnInteger( "/geometry/test/recursion_depth", this );
144 rcdCmd->SetGuidance( "Set the depth in the g 149 rcdCmd->SetGuidance( "Set the depth in the geometry tree for recursion." );
145 rcdCmd->SetGuidance( "recursive_test will th 150 rcdCmd->SetGuidance( "recursive_test will then stop after reached the specified depth." );
146 rcdCmd->SetGuidance( "By default, recursion 151 rcdCmd->SetGuidance( "By default, recursion will proceed for the whole depth." );
147 rcdCmd->SetParameterName("recursion_depth",t 152 rcdCmd->SetParameterName("recursion_depth",true);
148 rcdCmd->SetDefaultValue(-1); 153 rcdCmd->SetDefaultValue(-1);
149 154
150 errCmd = new G4UIcmdWithAnInteger( "/geometr 155 errCmd = new G4UIcmdWithAnInteger( "/geometry/test/maximum_errors", this );
151 errCmd->SetGuidance( "Set the maximum number 156 errCmd->SetGuidance( "Set the maximum number of overlap errors to report" );
152 errCmd->SetGuidance( "for each single volume 157 errCmd->SetGuidance( "for each single volume being checked." );
153 errCmd->SetGuidance( "Once reached the maxim 158 errCmd->SetGuidance( "Once reached the maximum number specified, overlaps" );
154 errCmd->SetGuidance( "affecting that volume 159 errCmd->SetGuidance( "affecting that volume further than that are simply ignored." );
155 errCmd->SetParameterName("maximum_errors",tr 160 errCmd->SetParameterName("maximum_errors",true);
156 errCmd->SetDefaultValue(1); 161 errCmd->SetDefaultValue(1);
157 162
158 parCmd = new G4UIcmdWithABool( "/geometry/te <<
159 parCmd->SetGuidance( "Check for overlaps in <<
160 parCmd->SetGuidance( "By default, overlaps a <<
161 parCmd->SetParameterName("check_parallel",tr <<
162 parCmd->SetDefaultValue(true); <<
163 <<
164 recCmd = new G4UIcmdWithoutParameter( "/geom 163 recCmd = new G4UIcmdWithoutParameter( "/geometry/test/run", this );
165 recCmd->SetGuidance( "Start running the recu 164 recCmd->SetGuidance( "Start running the recursive overlap check." );
166 recCmd->SetGuidance( "Volumes are recursivel 165 recCmd->SetGuidance( "Volumes are recursively asked to verify for overlaps" );
167 recCmd->SetGuidance( "for points generated o 166 recCmd->SetGuidance( "for points generated on the surface against their" );
168 recCmd->SetGuidance( "respective mother volu 167 recCmd->SetGuidance( "respective mother volume and sisters at the same" );
169 recCmd->SetGuidance( "level, performing for 168 recCmd->SetGuidance( "level, performing for all daughters and daughters of" );
170 recCmd->SetGuidance( "daughters, etc." ); 169 recCmd->SetGuidance( "daughters, etc." );
171 recCmd->SetGuidance( "NOTE: it may take a ve 170 recCmd->SetGuidance( "NOTE: it may take a very long time," );
172 recCmd->SetGuidance( " depending on the 171 recCmd->SetGuidance( " depending on the geometry complexity !");
173 recCmd->AvailableForStates(G4State_Idle); 172 recCmd->AvailableForStates(G4State_Idle);
174 } 173 }
175 174
176 // 175 //
177 // Destructor 176 // Destructor
178 // 177 //
179 G4GeometryMessenger::~G4GeometryMessenger() 178 G4GeometryMessenger::~G4GeometryMessenger()
180 { 179 {
181 delete verCmd; delete recCmd; delete rslCmd; 180 delete verCmd; delete recCmd; delete rslCmd;
182 delete resCmd; delete rcsCmd; delete rcdCmd; << 181 delete resCmd; delete rcsCmd; delete rcdCmd; delete errCmd;
183 delete errCmd; delete parCmd; delete tolCmd; << 182 delete tolCmd;
184 delete verbCmd; delete pchkCmd; delete chkCm 183 delete verbCmd; delete pchkCmd; delete chkCmd;
185 delete geodir; delete navdir; delete testdir 184 delete geodir; delete navdir; delete testdir;
186 for(auto* tvolume: tvolumes) { << 185 delete tvolume;
187 delete tvolume; <<
188 } <<
189 } 186 }
190 187
191 // 188 //
192 // Init 189 // Init
193 // 190 //
194 void 191 void
195 G4GeometryMessenger::Init() 192 G4GeometryMessenger::Init()
196 { 193 {
197 // Create checker... 194 // Create checker...
198 // 195 //
199 if (tvolumes.empty()) << 196 if (!tvolume)
200 { 197 {
201 // Get all world volumes << 198 // Get the world volume
>> 199 //
>> 200 G4VPhysicalVolume* world =
>> 201 tmanager->GetNavigatorForTracking()->GetWorldVolume();
>> 202
>> 203 // Test the actual detector...
202 // 204 //
203 const auto noWorlds = tmanager->GetNoWorld << 205 tvolume = new G4GeomTestVolume(world);
204 const auto fWorld = tmanager->GetWorldsIte <<
205 for(size_t i=0;i<noWorlds;++i) <<
206 { <<
207 // Test the actual detector... <<
208 // <<
209 tvolumes.push_back(new G4GeomTestVolum <<
210 } <<
211 } 206 }
212 } 207 }
213 208
214 // 209 //
215 // SetNewValue 210 // SetNewValue
216 // 211 //
217 void 212 void
218 G4GeometryMessenger::SetNewValue( G4UIcommand* 213 G4GeometryMessenger::SetNewValue( G4UIcommand* command, G4String newValues )
219 { 214 {
220 if (command == resCmd) { 215 if (command == resCmd) {
221 ResetNavigator(); 216 ResetNavigator();
222 } 217 }
223 else if (command == verbCmd) { 218 else if (command == verbCmd) {
224 SetVerbosity( newValues ); 219 SetVerbosity( newValues );
225 } 220 }
226 else if (command == chkCmd) { 221 else if (command == chkCmd) {
227 SetCheckMode( newValues ); 222 SetCheckMode( newValues );
228 } 223 }
229 else if (command == pchkCmd) { <<
230 SetPushFlag( newValues ); <<
231 } <<
232 else if (command == tolCmd) { 224 else if (command == tolCmd) {
233 Init(); 225 Init();
234 tol = tolCmd->GetNewDoubleValue( newValues 226 tol = tolCmd->GetNewDoubleValue( newValues )
235 * tolCmd->GetNewUnitValue( newValues ) 227 * tolCmd->GetNewUnitValue( newValues );
236 for(auto* tvolume: tvolumes) << 228 tvolume->SetTolerance(tol);
237 { <<
238 tvolume->SetTolerance(tol); <<
239 } <<
240 } 229 }
241 else if (command == verCmd) { 230 else if (command == verCmd) {
242 Init(); 231 Init();
243 for(auto* tvolume: tvolumes) << 232 tvolume->SetVerbosity(verCmd->GetNewBoolValue( newValues ));
244 { <<
245 tvolume->SetVerbosity(verCmd->GetNewBool <<
246 } <<
247 } 233 }
248 else if (command == rslCmd) { 234 else if (command == rslCmd) {
249 Init(); 235 Init();
250 for(auto* tvolume: tvolumes) << 236 tvolume->SetResolution(rslCmd->GetNewIntValue( newValues ));
251 { <<
252 tvolume->SetResolution(rslCmd->GetNewInt <<
253 } <<
254 } 237 }
255 else if (command == rcsCmd) { 238 else if (command == rcsCmd) {
256 recLevel = rcsCmd->GetNewIntValue( newValu 239 recLevel = rcsCmd->GetNewIntValue( newValues );
257 } 240 }
258 else if (command == rcdCmd) { 241 else if (command == rcdCmd) {
259 recDepth = rcdCmd->GetNewIntValue( newValu 242 recDepth = rcdCmd->GetNewIntValue( newValues );
260 } 243 }
261 else if (command == parCmd) { <<
262 checkParallelWorlds = parCmd->GetNewBoolVa <<
263 } <<
264 else if (command == errCmd) { 244 else if (command == errCmd) {
265 Init(); 245 Init();
266 for(auto* tvolume: tvolumes) << 246 tvolume->SetErrorsThreshold(errCmd->GetNewIntValue( newValues ));
267 { <<
268 tvolume->SetErrorsThreshold(errCmd->GetN <<
269 } <<
270 } 247 }
271 else if (command == recCmd) { 248 else if (command == recCmd) {
272 Init(); 249 Init();
273 G4cout << "Running geometry overlaps check 250 G4cout << "Running geometry overlaps check..." << G4endl;
274 RecursiveOverlapTest(); 251 RecursiveOverlapTest();
275 G4cout << "Geometry overlaps check complet 252 G4cout << "Geometry overlaps check completed !" << G4endl;
276 } 253 }
277 } 254 }
278 255
279 // 256 //
280 // GetCurrentValue 257 // GetCurrentValue
281 // 258 //
282 G4String 259 G4String
283 G4GeometryMessenger::GetCurrentValue( G4UIcomm << 260 G4GeometryMessenger::GetCurrentValue(G4UIcommand* command )
284 { 261 {
285 G4String cv = ""; 262 G4String cv = "";
286 if (command == tolCmd) << 263 if (command == tolCmd) {
287 { <<
288 cv = tolCmd->ConvertToString( tol, "mm" ); 264 cv = tolCmd->ConvertToString( tol, "mm" );
289 } 265 }
290 return cv; 266 return cv;
291 } 267 }
292 268
293 // 269 //
294 // CheckGeometry 270 // CheckGeometry
295 // 271 //
296 void 272 void
297 G4GeometryMessenger::CheckGeometry() 273 G4GeometryMessenger::CheckGeometry()
298 { 274 {
299 // Verify that the geometry is closed 275 // Verify that the geometry is closed
300 // 276 //
301 G4GeometryManager* geomManager = G4GeometryM 277 G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
302 if (!geomManager->IsGeometryClosed()) << 278 if (!geomManager->IsGeometryClosed()) {
303 { <<
304 geomManager->OpenGeometry(); 279 geomManager->OpenGeometry();
305 geomManager->CloseGeometry(true); 280 geomManager->CloseGeometry(true);
306 } 281 }
307 } 282 }
308 283
309 // 284 //
310 // ResetNavigator 285 // ResetNavigator
311 // 286 //
312 void 287 void
313 G4GeometryMessenger::ResetNavigator() 288 G4GeometryMessenger::ResetNavigator()
314 { 289 {
315 // Close geometry and reset optimisation if 290 // Close geometry and reset optimisation if necessary
316 // 291 //
317 CheckGeometry(); 292 CheckGeometry();
318 293
319 // Reset navigator's state 294 // Reset navigator's state
320 // 295 //
321 G4ThreeVector pt(0,0,0); 296 G4ThreeVector pt(0,0,0);
322 G4Navigator* navigator = tmanager->GetNaviga 297 G4Navigator* navigator = tmanager->GetNavigatorForTracking();
323 navigator->LocateGlobalPointAndSetup(pt,null << 298 navigator->LocateGlobalPointAndSetup(pt,0,false);
324 } 299 }
325 300
326 // 301 //
327 // Set navigator verbosity 302 // Set navigator verbosity
328 // 303 //
329 void 304 void
330 G4GeometryMessenger::SetVerbosity(const G4Stri << 305 G4GeometryMessenger::SetVerbosity(G4String input)
331 { 306 {
332 G4int level = verbCmd->GetNewIntValue(input) 307 G4int level = verbCmd->GetNewIntValue(input);
333 G4Navigator* navigator = tmanager->GetNaviga 308 G4Navigator* navigator = tmanager->GetNavigatorForTracking();
334 navigator->SetVerboseLevel(level); 309 navigator->SetVerboseLevel(level);
335 } 310 }
336 311
337 // 312 //
338 // Set navigator mode 313 // Set navigator mode
339 // 314 //
340 void 315 void
341 G4GeometryMessenger::SetCheckMode(const G4Stri << 316 G4GeometryMessenger::SetCheckMode(G4String input)
342 { 317 {
343 G4bool mode = chkCmd->GetNewBoolValue(input) 318 G4bool mode = chkCmd->GetNewBoolValue(input);
344 G4Navigator* navigator = tmanager->GetNaviga 319 G4Navigator* navigator = tmanager->GetNavigatorForTracking();
345 navigator->CheckMode(mode); 320 navigator->CheckMode(mode);
346 G4PropagatorInField* pField = tmanager->GetP <<
347 if (pField != nullptr) { pField->CheckMode( <<
348 } 321 }
349 322
350 // 323 //
351 // Set navigator verbosity for push notificati 324 // Set navigator verbosity for push notifications
352 // 325 //
353 void 326 void
354 G4GeometryMessenger::SetPushFlag(const G4Strin << 327 G4GeometryMessenger::SetPushFlag(G4String input)
355 { 328 {
356 G4bool mode = pchkCmd->GetNewBoolValue(input 329 G4bool mode = pchkCmd->GetNewBoolValue(input);
357 G4Navigator* navigator = tmanager->GetNaviga 330 G4Navigator* navigator = tmanager->GetNavigatorForTracking();
358 navigator->SetPushVerbosity(mode); 331 navigator->SetPushVerbosity(mode);
359 } 332 }
360 333
361 // 334 //
362 // Recursive Overlap Test 335 // Recursive Overlap Test
363 // 336 //
364 void 337 void
365 G4GeometryMessenger::RecursiveOverlapTest() 338 G4GeometryMessenger::RecursiveOverlapTest()
366 { 339 {
367 // Close geometry if necessary 340 // Close geometry if necessary
368 // 341 //
369 CheckGeometry(); 342 CheckGeometry();
370 343
371 // Make test on single line supplied by user 344 // Make test on single line supplied by user recursively
372 // 345 //
373 if (checkParallelWorlds) << 346 tvolume->TestRecursiveOverlap( recLevel, recDepth );
374 { <<
375 for(auto* tvolume: tvolumes) <<
376 { <<
377 tvolume->TestRecursiveOverlap( recLevel, <<
378 } <<
379 } <<
380 else <<
381 { <<
382 tvolumes.front()->TestRecursiveOverlap( re <<
383 } <<
384 } 347 }
385 348