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