| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // G4Navigator class Inline implementation
27 //
28 // --------------------------------------------------------------------
29
30 // ********************************************************************
31 // GetCurrentLocalCoordinate
32 //
33 // Returns the local coordinate of the current track
34 // ********************************************************************
35 //
36 inline
37 G4ThreeVector G4Navigator::GetCurrentLocalCoordinate() const
38 {
39 return fLastLocatedPointLocal;
40 }
41
42 // ********************************************************************
43 // ComputeLocalAxis
44 //
45 // Returns local direction of vector direction in world coord system
46 // ********************************************************************
47 //
48 inline
49 G4ThreeVector G4Navigator::ComputeLocalAxis(const G4ThreeVector& pVec) const
50 {
51 return fHistory.GetTopTransform().TransformAxis(pVec);
52 }
53
54 // ********************************************************************
55 // ComputeLocalPoint
56 //
57 // Returns local coordinates of a point in the world coord system
58 // ********************************************************************
59 //
60 inline
61 G4ThreeVector
62 G4Navigator::ComputeLocalPoint(const G4ThreeVector& pGlobalPoint) const
63 {
64 return fHistory.GetTopTransform().TransformPoint(pGlobalPoint);
65 }
66
67 // ********************************************************************
68 // GetWorldVolume
69 //
70 // Returns the current world (`topmost') volume
71 // ********************************************************************
72 //
73 inline
74 G4VPhysicalVolume* G4Navigator::GetWorldVolume() const
75 {
76 return fTopPhysical;
77 }
78
79 // ********************************************************************
80 // SetWorldVolume
81 //
82 // Sets the world (`topmost') volume
83 // ********************************************************************
84 //
85 inline
86 void G4Navigator::SetWorldVolume(G4VPhysicalVolume* pWorld)
87 {
88 if ( !(pWorld->GetTranslation() == G4ThreeVector(0,0,0)) )
89 {
90 G4Exception ("G4Navigator::SetWorldVolume()", "GeomNav0002",
91 FatalException, "Volume must be centered on the origin.");
92 }
93 const G4RotationMatrix* rm = pWorld->GetRotation();
94 if ( (rm != nullptr) && (!rm->isIdentity()) )
95 {
96 G4Exception ("G4Navigator::SetWorldVolume()", "GeomNav0002",
97 FatalException, "Volume must not be rotated.");
98 }
99 fTopPhysical = pWorld;
100 fHistory.SetFirstEntry(pWorld);
101 }
102
103 // ********************************************************************
104 // SetGeometrycallyLimitedStep
105 //
106 // Informs the navigator that the previous Step calculated
107 // by the geometry was taken in its entirety
108 // ********************************************************************
109 //
110 inline
111 void G4Navigator::SetGeometricallyLimitedStep()
112 {
113 fWasLimitedByGeometry = true;
114 }
115
116 // ********************************************************************
117 // ResetStackAndState
118 //
119 // Resets stack and minimum of navigator state `machine'
120 // ********************************************************************
121 //
122 inline
123 void G4Navigator::ResetStackAndState()
124 {
125 fHistory.Reset();
126 ResetState();
127 }
128
129 // ********************************************************************
130 // VolumeType
131 // ********************************************************************
132 //
133 inline
134 EVolume G4Navigator::VolumeType(const G4VPhysicalVolume *pVol) const
135 {
136 return pVol->VolumeType();
137 }
138
139 // ********************************************************************
140 // CharacteriseDaughters
141 // ********************************************************************
142 //
143 inline
144 EVolume G4Navigator::CharacteriseDaughters(const G4LogicalVolume *pLog) const
145 {
146 return pLog->CharacteriseDaughters();
147 }
148
149 // ********************************************************************
150 // GetDaughtersRegularStructureId
151 // ********************************************************************
152 //
153 inline
154 G4int G4Navigator::
155 GetDaughtersRegularStructureId(const G4LogicalVolume *pLog) const
156 {
157 G4int regId = 0;
158 G4VPhysicalVolume *pVol;
159
160 if ( pLog->GetNoDaughters() == 1 )
161 {
162 pVol = pLog->GetDaughter(0);
163 regId = pVol->GetRegularStructureId();
164 }
165 return regId;
166 }
167
168 // ********************************************************************
169 // GetGlobalToLocalTransform
170 //
171 // Returns local to global transformation.
172 // I.e. transformation that will take point or axis in world coord system
173 // and return one in the local coord system
174 // ********************************************************************
175 //
176 inline
177 const G4AffineTransform& G4Navigator::GetGlobalToLocalTransform() const
178 {
179 return fHistory.GetTopTransform();
180 }
181
182 // ********************************************************************
183 // GetLocalToGlobalTransform
184 //
185 // Returns global to local transformation
186 // ********************************************************************
187 //
188 inline
189 const G4AffineTransform G4Navigator::GetLocalToGlobalTransform() const
190 {
191 return fHistory.GetTopTransform().Inverse();
192 }
193
194 // ********************************************************************
195 // NetTranslation
196 //
197 // Computes+returns the local->global translation of current volume
198 // ********************************************************************
199 //
200 inline
201 G4ThreeVector G4Navigator::NetTranslation() const
202 {
203 return fHistory.GetTopTransform().InverseNetTranslation();
204 }
205
206 // ********************************************************************
207 // NetRotation
208 //
209 // Computes+returns the local->global rotation of current volume
210 // ********************************************************************
211 //
212 inline
213 G4RotationMatrix G4Navigator::NetRotation() const
214 {
215 return fHistory.GetTopTransform().InverseNetRotation();
216 }
217
218 // ********************************************************************
219 // CreateTouchableHistory
220 //
221 // `Touchable' creation method: caller has deletion responsibility
222 // ********************************************************************
223 //
224 inline
225 G4TouchableHistory* G4Navigator::CreateTouchableHistory() const
226 {
227 return new G4TouchableHistory(fHistory);
228 }
229
230 // ********************************************************************
231 // CreateTouchableHistory(history)
232 //
233 // `Touchable' creation method: caller has deletion responsibility
234 // ********************************************************************
235 //
236 inline
237 G4TouchableHistory*
238 G4Navigator::CreateTouchableHistory(const G4NavigationHistory* history) const
239 {
240 return new G4TouchableHistory(*history);
241 }
242
243 // ********************************************************************
244 // LocateGlobalPointAndUpdateTouchableHandle
245 // ********************************************************************
246 //
247 inline
248 void G4Navigator::LocateGlobalPointAndUpdateTouchableHandle(
249 const G4ThreeVector& position,
250 const G4ThreeVector& direction,
251 G4TouchableHandle& oldTouchableToUpdate,
252 const G4bool RelativeSearch )
253 {
254 G4VPhysicalVolume* pPhysVol;
255 pPhysVol = LocateGlobalPointAndSetup( position,&direction,RelativeSearch );
256 if( fEnteredDaughter || fExitedMother )
257 {
258 oldTouchableToUpdate = CreateTouchableHistory();
259 if( pPhysVol == nullptr )
260 {
261 // We want to ensure that the touchable is correct in this case.
262 // The method below should do this and recalculate a lot more ....
263 //
264 oldTouchableToUpdate->UpdateYourself( pPhysVol, &fHistory );
265 }
266 }
267 return;
268 }
269
270 // ********************************************************************
271 // LocateGlobalPointAndUpdateTouchable
272 //
273 // Use direction
274 // ********************************************************************
275 //
276 inline
277 void G4Navigator::LocateGlobalPointAndUpdateTouchable(
278 const G4ThreeVector& position,
279 const G4ThreeVector& direction,
280 G4VTouchable* touchableToUpdate,
281 const G4bool RelativeSearch )
282 {
283 G4VPhysicalVolume* pPhysVol;
284 pPhysVol = LocateGlobalPointAndSetup( position, &direction, RelativeSearch);
285 touchableToUpdate->UpdateYourself( pPhysVol, &fHistory );
286 }
287
288 // ********************************************************************
289 // LocateGlobalPointAndUpdateTouchable
290 // ********************************************************************
291 //
292 inline
293 void G4Navigator::LocateGlobalPointAndUpdateTouchable(
294 const G4ThreeVector& position,
295 G4VTouchable* touchableToUpdate,
296 const G4bool RelativeSearch )
297 {
298 G4VPhysicalVolume* pPhysVol;
299 pPhysVol = LocateGlobalPointAndSetup( position, nullptr, RelativeSearch);
300 touchableToUpdate->UpdateYourself( pPhysVol, &fHistory );
301 }
302
303 // ********************************************************************
304 // GetVerboseLevel
305 // ********************************************************************
306 //
307 inline
308 G4int G4Navigator::GetVerboseLevel() const
309 {
310 return fVerbose;
311 }
312
313 // ********************************************************************
314 // SetVerboseLevel
315 // ********************************************************************
316 //
317 inline
318 void G4Navigator::SetVerboseLevel(G4int level)
319 {
320 fVerbose = level;
321 fnormalNav.SetVerboseLevel(level);
322 GetVoxelNavigator().SetVerboseLevel(level);
323 fparamNav.SetVerboseLevel(level);
324 freplicaNav.SetVerboseLevel(level);
325 fregularNav.SetVerboseLevel(level);
326 if (fpExternalNav != nullptr) { fpExternalNav->SetVerboseLevel(level); }
327 }
328
329 // ********************************************************************
330 // IsActive
331 // ********************************************************************
332 //
333 inline
334 G4bool G4Navigator::IsActive() const
335 {
336 return fActive;
337 }
338
339 // ********************************************************************
340 // Activate
341 // ********************************************************************
342 //
343 inline
344 void G4Navigator::Activate(G4bool flag)
345 {
346 fActive = flag;
347 }
348
349 // ********************************************************************
350 // EnteredDaughterVolume
351 //
352 // To inform the caller if the track is entering a daughter volume
353 // ********************************************************************
354 //
355 inline
356 G4bool G4Navigator::EnteredDaughterVolume() const
357 {
358 return fEnteredDaughter;
359 }
360
361 // ********************************************************************
362 // ExitedMotherVolume
363 // ********************************************************************
364 //
365 inline
366 G4bool G4Navigator::ExitedMotherVolume() const
367 {
368 return fExitedMother;
369 }
370
371 // ********************************************************************
372 // CheckMode
373 // ********************************************************************
374 //
375 inline
376 void G4Navigator::CheckMode(G4bool mode)
377 {
378 fCheck = mode;
379 fnormalNav.CheckMode(mode);
380 GetVoxelNavigator().CheckMode(mode);
381 fparamNav.CheckMode(mode);
382 freplicaNav.CheckMode(mode);
383 fregularNav.CheckMode(mode);
384 if (fpExternalNav != nullptr) { fpExternalNav->CheckMode(mode); }
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 }
406
407 // ********************************************************************
408 // SeverityOfZeroStepping
409 //
410 // Reports on severity of error in case Navigator is stuck
411 // and is returning zero steps
412 // ********************************************************************
413 //
414 inline
415 G4int G4Navigator::SeverityOfZeroStepping( G4int* noZeroSteps ) const
416 {
417 G4int severity = 0, noZeros = fNumberZeroSteps;
418 if( noZeroSteps != nullptr )
419 {
420 *noZeroSteps = fNumberZeroSteps;
421 }
422 if( noZeros >= fAbandonThreshold_NoZeroSteps )
423 {
424 severity = 10;
425 }
426 if( noZeros > 0 && noZeros < fActionThreshold_NoZeroSteps )
427 {
428 severity = 5 * noZeros / fActionThreshold_NoZeroSteps;
429 }
430 else if( noZeros == fActionThreshold_NoZeroSteps )
431 {
432 severity = 5;
433 }
434 else if( noZeros >= fAbandonThreshold_NoZeroSteps - 2 )
435 {
436 severity = 9;
437 }
438 else if( noZeros < fAbandonThreshold_NoZeroSteps - 2 )
439 {
440 severity = 5 + 4 * (noZeros-fAbandonThreshold_NoZeroSteps)
441 / fActionThreshold_NoZeroSteps;
442 }
443 return severity;
444 }
445
446 // ********************************************************************
447 // GetVoxelNavigator
448 // ********************************************************************
449 //
450 inline
451 G4VoxelNavigation& G4Navigator::GetVoxelNavigator()
452 {
453 return *fpvoxelNav;
454 }
455
456 // ********************************************************************
457 // EnableBestSafety
458 // ********************************************************************
459 //
460 inline void G4Navigator::EnableBestSafety( G4bool value )
461 {
462 GetVoxelNavigator().EnableBestSafety( value );
463 }
464
465 // ********************************************************************
466 // SetExternalNavigation
467 // ********************************************************************
468 //
469 inline
470 G4VExternalNavigation* G4Navigator::GetExternalNavigation() const
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(fpExternalNav->Clone());
487 }
488 return clone_nav;
489 }
490