| 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 // G4Navigator class Inline implementation <<
27 // 26 //
28 // ------------------------------------------- << 27 // $Id: G4Navigator.icc,v 1.12 2006/10/27 09:13:46 gcosmo Exp $
>> 28 // GEANT4 tag $Name: geant4-08-02-patch-01-ref $
>> 29 //
>> 30 //
>> 31 // class G4Navigator Inline implementation
>> 32 //
>> 33 // ********************************************************************
29 34
30 // ******************************************* 35 // ********************************************************************
31 // GetCurrentLocalCoordinate 36 // GetCurrentLocalCoordinate
32 // 37 //
33 // Returns the local coordinate of the current 38 // Returns the local coordinate of the current track
34 // ******************************************* 39 // ********************************************************************
35 // 40 //
36 inline 41 inline
37 G4ThreeVector G4Navigator::GetCurrentLocalCoor 42 G4ThreeVector G4Navigator::GetCurrentLocalCoordinate() const
38 { 43 {
39 return fLastLocatedPointLocal; 44 return fLastLocatedPointLocal;
40 } 45 }
41 46
42 // ******************************************* 47 // ********************************************************************
43 // ComputeLocalAxis 48 // ComputeLocalAxis
44 // 49 //
45 // Returns local direction of vector direction 50 // Returns local direction of vector direction in world coord system
46 // ******************************************* 51 // ********************************************************************
47 // 52 //
48 inline 53 inline
49 G4ThreeVector G4Navigator::ComputeLocalAxis(co 54 G4ThreeVector G4Navigator::ComputeLocalAxis(const G4ThreeVector& pVec) const
50 { 55 {
51 return fHistory.GetTopTransform().TransformA << 56 return (fHistory.GetTopTransform().IsRotated())
>> 57 ? fHistory.GetTopTransform().TransformAxis(pVec) : pVec ;
52 } 58 }
53 59
54 // ******************************************* 60 // ********************************************************************
55 // ComputeLocalPoint 61 // ComputeLocalPoint
56 // 62 //
57 // Returns local coordinates of a point in the 63 // Returns local coordinates of a point in the world coord system
58 // ******************************************* 64 // ********************************************************************
59 // 65 //
60 inline 66 inline
61 G4ThreeVector 67 G4ThreeVector
62 G4Navigator::ComputeLocalPoint(const G4ThreeVe 68 G4Navigator::ComputeLocalPoint(const G4ThreeVector& pGlobalPoint) const
63 { 69 {
64 return fHistory.GetTopTransform().TransformP << 70 return ( fHistory.GetTopTransform().TransformPoint(pGlobalPoint) ) ;
65 } 71 }
66 72
67 // ******************************************* 73 // ********************************************************************
68 // GetWorldVolume 74 // GetWorldVolume
69 // 75 //
70 // Returns the current world (`topmost') volu 76 // Returns the current world (`topmost') volume
71 // ******************************************* 77 // ********************************************************************
72 // 78 //
73 inline 79 inline
74 G4VPhysicalVolume* G4Navigator::GetWorldVolume 80 G4VPhysicalVolume* G4Navigator::GetWorldVolume() const
75 { 81 {
76 return fTopPhysical; 82 return fTopPhysical;
77 } 83 }
78 84
79 // ******************************************* 85 // ********************************************************************
80 // SetWorldVolume 86 // SetWorldVolume
81 // 87 //
82 // Sets the world (`topmost') volume 88 // Sets the world (`topmost') volume
83 // ******************************************* 89 // ********************************************************************
84 // 90 //
85 inline 91 inline
86 void G4Navigator::SetWorldVolume(G4VPhysicalVo 92 void G4Navigator::SetWorldVolume(G4VPhysicalVolume* pWorld)
87 { 93 {
88 if ( !(pWorld->GetTranslation() == G4ThreeVe << 94 if ( !(pWorld->GetTranslation()==G4ThreeVector(0,0,0)) )
89 { 95 {
90 G4Exception ("G4Navigator::SetWorldVolume( << 96 G4Exception ("G4Navigator::SetWorldVolume()", "InvalidSetup",
91 FatalException, "Volume must 97 FatalException, "Volume must be centered on the origin.");
92 } 98 }
93 const G4RotationMatrix* rm = pWorld->GetRota 99 const G4RotationMatrix* rm = pWorld->GetRotation();
94 if ( (rm != nullptr) && (!rm->isIdentity()) << 100 if ( rm && (!rm->isIdentity()) )
95 { 101 {
96 G4Exception ("G4Navigator::SetWorldVolume( << 102 G4Exception ("G4Navigator::SetWorldVolume()", "InvalidSetup",
97 FatalException, "Volume must 103 FatalException, "Volume must not be rotated.");
98 } 104 }
99 fTopPhysical = pWorld; 105 fTopPhysical = pWorld;
100 fHistory.SetFirstEntry(pWorld); 106 fHistory.SetFirstEntry(pWorld);
101 } 107 }
102 108
103 // ******************************************* 109 // ********************************************************************
104 // SetGeometrycallyLimitedStep 110 // SetGeometrycallyLimitedStep
105 // 111 //
106 // Informs the navigator that the previous Ste 112 // Informs the navigator that the previous Step calculated
107 // by the geometry was taken in its entirety 113 // by the geometry was taken in its entirety
108 // ******************************************* 114 // ********************************************************************
109 // 115 //
110 inline 116 inline
111 void G4Navigator::SetGeometricallyLimitedStep( 117 void G4Navigator::SetGeometricallyLimitedStep()
112 { 118 {
113 fWasLimitedByGeometry = true; << 119 fWasLimitedByGeometry=true;
114 } 120 }
115 121
116 // ******************************************* 122 // ********************************************************************
117 // ResetStackAndState 123 // ResetStackAndState
118 // 124 //
119 // Resets stack and minimum of navigator state 125 // Resets stack and minimum of navigator state `machine'
120 // ******************************************* 126 // ********************************************************************
121 // 127 //
122 inline 128 inline
123 void G4Navigator::ResetStackAndState() 129 void G4Navigator::ResetStackAndState()
124 { 130 {
125 fHistory.Reset(); 131 fHistory.Reset();
126 ResetState(); 132 ResetState();
127 } 133 }
128 134
129 // ******************************************* 135 // ********************************************************************
130 // VolumeType 136 // VolumeType
131 // ******************************************* 137 // ********************************************************************
132 // 138 //
133 inline 139 inline
134 EVolume G4Navigator::VolumeType(const G4VPhysi 140 EVolume G4Navigator::VolumeType(const G4VPhysicalVolume *pVol) const
135 { 141 {
136 return pVol->VolumeType(); << 142 EVolume type;
>> 143 EAxis axis;
>> 144 G4int nReplicas;
>> 145 G4double width,offset;
>> 146 G4bool consuming;
>> 147 if ( pVol->IsReplicated() )
>> 148 {
>> 149 pVol->GetReplicationData(axis,nReplicas,width,offset,consuming);
>> 150 type = (consuming) ? kReplica : kParameterised;
>> 151 }
>> 152 else
>> 153 {
>> 154 type = kNormal;
>> 155 }
>> 156 return type;
137 } 157 }
138 158
139 // ******************************************* 159 // ********************************************************************
140 // CharacteriseDaughters << 160 // CharacteriseDahghters
141 // ******************************************* 161 // ********************************************************************
142 // 162 //
143 inline 163 inline
144 EVolume G4Navigator::CharacteriseDaughters(con 164 EVolume G4Navigator::CharacteriseDaughters(const G4LogicalVolume *pLog) const
145 { 165 {
146 return pLog->CharacteriseDaughters(); << 166 EVolume type;
147 } << 167 EAxis axis;
148 << 168 G4int nReplicas;
149 // ******************************************* << 169 G4double width,offset;
150 // GetDaughtersRegularStructureId << 170 G4bool consuming;
151 // ******************************************* <<
152 // <<
153 inline <<
154 G4int G4Navigator:: <<
155 GetDaughtersRegularStructureId(const G4Logical <<
156 { <<
157 G4int regId = 0; <<
158 G4VPhysicalVolume *pVol; 171 G4VPhysicalVolume *pVol;
159 172
160 if ( pLog->GetNoDaughters() == 1 ) << 173 if ( pLog->GetNoDaughters()==1 )
161 { 174 {
162 pVol = pLog->GetDaughter(0); 175 pVol = pLog->GetDaughter(0);
163 regId = pVol->GetRegularStructureId(); << 176 if (pVol->IsReplicated())
>> 177 {
>> 178 pVol->GetReplicationData(axis,nReplicas,width,offset,consuming);
>> 179 type = (consuming) ? kReplica : kParameterised;
>> 180 }
>> 181 else
>> 182 {
>> 183 type = kNormal;
>> 184 }
164 } 185 }
165 return regId; << 186 else
>> 187 {
>> 188 type = kNormal;
>> 189 }
>> 190 return type;
166 } 191 }
167 192
168 // ******************************************* 193 // ********************************************************************
169 // GetGlobalToLocalTransform 194 // GetGlobalToLocalTransform
170 // 195 //
171 // Returns local to global transformation. 196 // Returns local to global transformation.
172 // I.e. transformation that will take point or 197 // I.e. transformation that will take point or axis in world coord system
173 // and return one in the local coord system 198 // and return one in the local coord system
174 // ******************************************* 199 // ********************************************************************
175 // 200 //
176 inline 201 inline
177 const G4AffineTransform& G4Navigator::GetGloba 202 const G4AffineTransform& G4Navigator::GetGlobalToLocalTransform() const
178 { 203 {
179 return fHistory.GetTopTransform(); 204 return fHistory.GetTopTransform();
180 } 205 }
181 206
182 // ******************************************* 207 // ********************************************************************
183 // GetLocalToGlobalTransform 208 // GetLocalToGlobalTransform
184 // 209 //
185 // Returns global to local transformation 210 // Returns global to local transformation
186 // ******************************************* 211 // ********************************************************************
187 // 212 //
188 inline 213 inline
189 const G4AffineTransform G4Navigator::GetLocalT 214 const G4AffineTransform G4Navigator::GetLocalToGlobalTransform() const
190 { 215 {
191 return fHistory.GetTopTransform().Inverse(); << 216 G4AffineTransform tempTransform;
>> 217 tempTransform = fHistory.GetTopTransform().Inverse();
>> 218 return tempTransform;
192 } 219 }
193 220
194 // ******************************************* 221 // ********************************************************************
195 // NetTranslation 222 // NetTranslation
196 // 223 //
197 // Computes+returns the local->global translat 224 // Computes+returns the local->global translation of current volume
198 // ******************************************* 225 // ********************************************************************
199 // 226 //
200 inline 227 inline
201 G4ThreeVector G4Navigator::NetTranslation() co 228 G4ThreeVector G4Navigator::NetTranslation() const
202 { 229 {
203 return fHistory.GetTopTransform().InverseNet << 230 G4AffineTransform tf(fHistory.GetTopTransform().Inverse());
>> 231 return tf.NetTranslation();
204 } 232 }
205 233
206 // ******************************************* 234 // ********************************************************************
207 // NetRotation 235 // NetRotation
208 // 236 //
209 // Computes+returns the local->global rotation 237 // Computes+returns the local->global rotation of current volume
210 // ******************************************* 238 // ********************************************************************
211 // 239 //
212 inline 240 inline
213 G4RotationMatrix G4Navigator::NetRotation() co 241 G4RotationMatrix G4Navigator::NetRotation() const
214 { 242 {
215 return fHistory.GetTopTransform().InverseNet << 243 G4AffineTransform tf(fHistory.GetTopTransform().Inverse());
>> 244 return tf.NetRotation();
216 } 245 }
217 246
218 // ******************************************* 247 // ********************************************************************
219 // CreateTouchableHistory << 248 // CreateGRSVolume
220 // 249 //
221 // `Touchable' creation method: caller has del 250 // `Touchable' creation method: caller has deletion responsibility
222 // ******************************************* 251 // ********************************************************************
223 // 252 //
224 inline 253 inline
225 G4TouchableHistory* G4Navigator::CreateTouchab << 254 G4GRSVolume* G4Navigator::CreateGRSVolume() const
226 { 255 {
227 return new G4TouchableHistory(fHistory); << 256 G4AffineTransform tf(fHistory.GetTopTransform().Inverse());
>> 257 return new G4GRSVolume(fHistory.GetTopVolume(),
>> 258 tf.NetRotation(),
>> 259 tf.NetTranslation());
228 } 260 }
229 261
230 // ******************************************* 262 // ********************************************************************
231 // CreateTouchableHistory(history) << 263 // CreateGRSSolid
232 // 264 //
233 // `Touchable' creation method: caller has del 265 // `Touchable' creation method: caller has deletion responsibility
234 // ******************************************* 266 // ********************************************************************
235 // 267 //
236 inline 268 inline
237 G4TouchableHistory* << 269 G4GRSSolid* G4Navigator::CreateGRSSolid() const
238 G4Navigator::CreateTouchableHistory(const G4Na <<
239 { 270 {
240 return new G4TouchableHistory(*history); << 271 G4AffineTransform tf(fHistory.GetTopTransform().Inverse());
>> 272 return new G4GRSSolid(fHistory.GetTopVolume()->GetLogicalVolume()->GetSolid(),
>> 273 tf.NetRotation(),
>> 274 tf.NetTranslation());
>> 275 }
>> 276
>> 277 // ********************************************************************
>> 278 // CreateTouchableHistory
>> 279 //
>> 280 // `Touchable' creation method: caller has deletion responsibility
>> 281 // ********************************************************************
>> 282 //
>> 283 inline
>> 284 G4TouchableHistory* G4Navigator::CreateTouchableHistory() const
>> 285 {
>> 286 return new G4TouchableHistory(fHistory);
241 } 287 }
242 288
243 // ******************************************* 289 // ********************************************************************
244 // LocateGlobalPointAndUpdateTouchableHandle 290 // LocateGlobalPointAndUpdateTouchableHandle
245 // ******************************************* 291 // ********************************************************************
246 // 292 //
247 inline 293 inline
248 void G4Navigator::LocateGlobalPointAndUpdateTo 294 void G4Navigator::LocateGlobalPointAndUpdateTouchableHandle(
249 const G4ThreeVe 295 const G4ThreeVector& position,
250 const G4ThreeVe 296 const G4ThreeVector& direction,
251 G4Touchab 297 G4TouchableHandle& oldTouchableToUpdate,
252 const G4bool 298 const G4bool RelativeSearch )
253 { 299 {
254 G4VPhysicalVolume* pPhysVol; 300 G4VPhysicalVolume* pPhysVol;
255 pPhysVol = LocateGlobalPointAndSetup( positi 301 pPhysVol = LocateGlobalPointAndSetup( position,&direction,RelativeSearch );
256 if( fEnteredDaughter || fExitedMother ) 302 if( fEnteredDaughter || fExitedMother )
257 { 303 {
258 oldTouchableToUpdate = CreateTouchableHis 304 oldTouchableToUpdate = CreateTouchableHistory();
259 if( pPhysVol == nullptr ) << 305 if( pPhysVol == 0 )
260 { 306 {
261 // We want to ensure that the touchable 307 // We want to ensure that the touchable is correct in this case.
262 // The method below should do this and << 308 // The method below should do this and recalculate a lot more ....
263 // 309 //
264 oldTouchableToUpdate->UpdateYourself( p 310 oldTouchableToUpdate->UpdateYourself( pPhysVol, &fHistory );
265 } 311 }
266 } 312 }
267 return; 313 return;
268 } 314 }
269 315
270 // ******************************************* 316 // ********************************************************************
271 // LocateGlobalPointAndUpdateTouchable 317 // LocateGlobalPointAndUpdateTouchable
272 // 318 //
273 // Use direction 319 // Use direction
274 // ******************************************* 320 // ********************************************************************
275 // 321 //
276 inline 322 inline
277 void G4Navigator::LocateGlobalPointAndUpdateTo 323 void G4Navigator::LocateGlobalPointAndUpdateTouchable(
278 const G4ThreeVector 324 const G4ThreeVector& position,
279 const G4ThreeVector 325 const G4ThreeVector& direction,
280 G4VTouchable* 326 G4VTouchable* touchableToUpdate,
281 const G4bool 327 const G4bool RelativeSearch )
282 { 328 {
283 G4VPhysicalVolume* pPhysVol; 329 G4VPhysicalVolume* pPhysVol;
284 pPhysVol = LocateGlobalPointAndSetup( positi 330 pPhysVol = LocateGlobalPointAndSetup( position, &direction, RelativeSearch);
285 touchableToUpdate->UpdateYourself( pPhysVol, 331 touchableToUpdate->UpdateYourself( pPhysVol, &fHistory );
286 } 332 }
287 333
288 // ******************************************* 334 // ********************************************************************
289 // LocateGlobalPointAndUpdateTouchable 335 // LocateGlobalPointAndUpdateTouchable
290 // ******************************************* 336 // ********************************************************************
291 // 337 //
292 inline 338 inline
293 void G4Navigator::LocateGlobalPointAndUpdateTo 339 void G4Navigator::LocateGlobalPointAndUpdateTouchable(
294 const G4ThreeVector 340 const G4ThreeVector& position,
295 G4VTouchable* 341 G4VTouchable* touchableToUpdate,
296 const G4bool 342 const G4bool RelativeSearch )
297 { 343 {
298 G4VPhysicalVolume* pPhysVol; 344 G4VPhysicalVolume* pPhysVol;
299 pPhysVol = LocateGlobalPointAndSetup( positi << 345 pPhysVol = LocateGlobalPointAndSetup( position, 0, RelativeSearch);
300 touchableToUpdate->UpdateYourself( pPhysVol, 346 touchableToUpdate->UpdateYourself( pPhysVol, &fHistory );
301 } 347 }
302 348
303 // ******************************************* 349 // ********************************************************************
304 // GetVerboseLevel 350 // GetVerboseLevel
305 // ******************************************* 351 // ********************************************************************
306 // 352 //
307 inline 353 inline
308 G4int G4Navigator::GetVerboseLevel() const 354 G4int G4Navigator::GetVerboseLevel() const
309 { 355 {
310 return fVerbose; 356 return fVerbose;
311 } 357 }
312 358
313 // ******************************************* 359 // ********************************************************************
314 // SetVerboseLevel 360 // SetVerboseLevel
315 // ******************************************* 361 // ********************************************************************
316 // 362 //
317 inline 363 inline
318 void G4Navigator::SetVerboseLevel(G4int level) 364 void G4Navigator::SetVerboseLevel(G4int level)
319 { 365 {
320 fVerbose = level; 366 fVerbose = level;
321 fnormalNav.SetVerboseLevel(level); 367 fnormalNav.SetVerboseLevel(level);
322 GetVoxelNavigator().SetVerboseLevel(level); << 368 fvoxelNav.SetVerboseLevel(level);
323 fparamNav.SetVerboseLevel(level); 369 fparamNav.SetVerboseLevel(level);
324 freplicaNav.SetVerboseLevel(level); 370 freplicaNav.SetVerboseLevel(level);
325 fregularNav.SetVerboseLevel(level); <<
326 if (fpExternalNav != nullptr) { fpExternalNa <<
327 } 371 }
328 372
329 // ******************************************* 373 // ********************************************************************
330 // IsActive 374 // IsActive
331 // ******************************************* 375 // ********************************************************************
332 // 376 //
333 inline 377 inline
334 G4bool G4Navigator::IsActive() const 378 G4bool G4Navigator::IsActive() const
335 { 379 {
336 return fActive; 380 return fActive;
337 } 381 }
338 382
339 // ******************************************* 383 // ********************************************************************
340 // Activate 384 // Activate
341 // ******************************************* 385 // ********************************************************************
342 // 386 //
343 inline 387 inline
344 void G4Navigator::Activate(G4bool flag) 388 void G4Navigator::Activate(G4bool flag)
345 { 389 {
346 fActive = flag; 390 fActive = flag;
347 } 391 }
348 392
349 // ******************************************* 393 // ********************************************************************
350 // EnteredDaughterVolume 394 // EnteredDaughterVolume
351 // 395 //
352 // To inform the caller if the track is enteri 396 // To inform the caller if the track is entering a daughter volume
353 // ******************************************* 397 // ********************************************************************
354 // 398 //
355 inline 399 inline
356 G4bool G4Navigator::EnteredDaughterVolume() co 400 G4bool G4Navigator::EnteredDaughterVolume() const
357 { 401 {
358 return fEnteredDaughter; 402 return fEnteredDaughter;
359 } 403 }
360 404
361 // ******************************************* 405 // ********************************************************************
362 // ExitedMotherVolume 406 // ExitedMotherVolume
363 // ******************************************* 407 // ********************************************************************
364 // 408 //
365 inline 409 inline
366 G4bool G4Navigator::ExitedMotherVolume() const 410 G4bool G4Navigator::ExitedMotherVolume() const
367 { 411 {
368 return fExitedMother; 412 return fExitedMother;
369 } 413 }
370 414
371 // ******************************************* 415 // ********************************************************************
372 // CheckMode 416 // CheckMode
373 // ******************************************* 417 // ********************************************************************
374 // 418 //
375 inline 419 inline
376 void G4Navigator::CheckMode(G4bool mode) 420 void G4Navigator::CheckMode(G4bool mode)
377 { 421 {
378 fCheck = mode; 422 fCheck = mode;
379 fnormalNav.CheckMode(mode); 423 fnormalNav.CheckMode(mode);
380 GetVoxelNavigator().CheckMode(mode); << 424 fvoxelNav.CheckMode(mode);
381 fparamNav.CheckMode(mode); 425 fparamNav.CheckMode(mode);
382 freplicaNav.CheckMode(mode); 426 freplicaNav.CheckMode(mode);
383 fregularNav.CheckMode(mode); <<
384 if (fpExternalNav != nullptr) { fpExternalNa <<
385 } <<
386 <<
387 // ******************************************* <<
388 // IsCheckModeActive <<
389 // ******************************************* <<
390 // <<
391 inline <<
392 G4bool G4Navigator::IsCheckModeActive() const <<
393 { <<
394 return fCheck; <<
395 } <<
396 <<
397 // ******************************************* <<
398 // SetPushVerbosity <<
399 // ******************************************* <<
400 // <<
401 inline <<
402 void G4Navigator::SetPushVerbosity(G4bool mode <<
403 { <<
404 fWarnPush = mode; <<
405 } 427 }
406 428
407 // ******************************************* 429 // ********************************************************************
408 // SeverityOfZeroStepping 430 // SeverityOfZeroStepping
409 // 431 //
410 // Reports on severity of error in case Naviga 432 // Reports on severity of error in case Navigator is stuck
411 // and is returning zero steps 433 // and is returning zero steps
412 // ******************************************* 434 // ********************************************************************
413 // 435 //
414 inline 436 inline
415 G4int G4Navigator::SeverityOfZeroStepping( G4i 437 G4int G4Navigator::SeverityOfZeroStepping( G4int* noZeroSteps ) const
416 { 438 {
417 G4int severity = 0, noZeros = fNumberZeroSte << 439 G4int severity=0, noZeros= fNumberZeroSteps;
418 if( noZeroSteps != nullptr ) << 440 if( noZeroSteps) *noZeroSteps = fNumberZeroSteps;
419 { << 441
420 *noZeroSteps = fNumberZeroSteps; <<
421 } <<
422 if( noZeros >= fAbandonThreshold_NoZeroSteps 442 if( noZeros >= fAbandonThreshold_NoZeroSteps )
423 { 443 {
424 severity = 10; 444 severity = 10;
425 } 445 }
426 if( noZeros > 0 && noZeros < fActionThreshol 446 if( noZeros > 0 && noZeros < fActionThreshold_NoZeroSteps )
427 { 447 {
428 severity = 5 * noZeros / fActionThreshold 448 severity = 5 * noZeros / fActionThreshold_NoZeroSteps;
429 } 449 }
430 else if( noZeros == fActionThreshold_NoZeroS 450 else if( noZeros == fActionThreshold_NoZeroSteps )
431 { 451 {
432 severity = 5; 452 severity = 5;
433 } 453 }
434 else if( noZeros >= fAbandonThreshold_NoZero 454 else if( noZeros >= fAbandonThreshold_NoZeroSteps - 2 )
435 { 455 {
436 severity = 9; 456 severity = 9;
437 } 457 }
438 else if( noZeros < fAbandonThreshold_NoZeroS 458 else if( noZeros < fAbandonThreshold_NoZeroSteps - 2 )
439 { 459 {
440 severity = 5 + 4 * (noZeros-fAbandonThres 460 severity = 5 + 4 * (noZeros-fAbandonThreshold_NoZeroSteps)
441 / fActionThreshold_NoZer 461 / fActionThreshold_NoZeroSteps;
442 } 462 }
443 return severity; 463 return severity;
444 } <<
445 <<
446 // ******************************************* <<
447 // GetVoxelNavigator <<
448 // ******************************************* <<
449 // <<
450 inline <<
451 G4VoxelNavigation& G4Navigator::GetVoxelNaviga <<
452 { <<
453 return *fpvoxelNav; <<
454 } <<
455 <<
456 // ******************************************* <<
457 // EnableBestSafety <<
458 // ******************************************* <<
459 // <<
460 inline void G4Navigator::EnableBestSafety( G4b <<
461 { <<
462 GetVoxelNavigator().EnableBestSafety( value <<
463 } <<
464 <<
465 // ******************************************* <<
466 // SetExternalNavigation <<
467 // ******************************************* <<
468 // <<
469 inline <<
470 G4VExternalNavigation* G4Navigator::GetExterna <<
471 { <<
472 return fpExternalNav; <<
473 } <<
474 <<
475 // ******************************************* <<
476 // Clone <<
477 // ******************************************* <<
478 // <<
479 inline <<
480 G4Navigator* G4Navigator::Clone() const <<
481 { <<
482 auto clone_nav = new G4Navigator(); <<
483 clone_nav->SetWorldVolume(fTopPhysical); <<
484 if( fpExternalNav != nullptr ) <<
485 { <<
486 clone_nav->SetExternalNavigation(fpExterna <<
487 } <<
488 return clone_nav; <<
489 } 464 }
490 465