| 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 // 26 //
27 // 27 //
28 // 28 //
29 // class G4ITSafetyHelper 29 // class G4ITSafetyHelper
30 // 30 //
31 // Class description: 31 // Class description:
32 // 32 //
33 // G4ITSafetyHelper is a duplicated version of 33 // G4ITSafetyHelper is a duplicated version of G4SafetyHelper
34 // This class is a helper for physics processe 34 // This class is a helper for physics processes which require
35 // knowledge of the safety, and the step size 35 // knowledge of the safety, and the step size for the 'mass' geometry
36 36
37 // First version: J. Apostolakis, July 5th, 37 // First version: J. Apostolakis, July 5th, 2006
38 // Modified: 38 // Modified:
39 // 10.04.07 V.Ivanchenko Use unique G4ITSafe 39 // 10.04.07 V.Ivanchenko Use unique G4ITSafetyHelper
40 // ------------------------------------------- 40 // --------------------------------------------------------------------
41 41
42 #ifndef G4ITSAFETYHELPER_HH 42 #ifndef G4ITSAFETYHELPER_HH
43 #define G4ITSAFETYHELPER_HH 1 43 #define G4ITSAFETYHELPER_HH 1
44 44
45 #include <vector> 45 #include <vector>
46 46
47 #include "G4Types.hh" 47 #include "G4Types.hh"
48 #include "G4ThreeVector.hh" 48 #include "G4ThreeVector.hh"
49 #include "G4ITNavigator.hh" 49 #include "G4ITNavigator.hh"
50 #include "G4TrackState.hh" 50 #include "G4TrackState.hh"
51 51
52 class G4PathFinder; 52 class G4PathFinder;
53 53
54 class G4ITSafetyHelper : public G4TrackStateDe 54 class G4ITSafetyHelper : public G4TrackStateDependent<G4ITSafetyHelper>
55 { 55 {
56 public: 56 public:
57 // with description 57 // with description
58 G4ITSafetyHelper(); 58 G4ITSafetyHelper();
59 ~G4ITSafetyHelper() override; 59 ~G4ITSafetyHelper() override;
60 // 60 //
61 // Constructor and destructor 61 // Constructor and destructor
62 62
63 G4double CheckNextStep(const G4ThreeVector& 63 G4double CheckNextStep(const G4ThreeVector& position,
64 const G4ThreeVector& 64 const G4ThreeVector& direction,
65 const G4double curren 65 const G4double currentMaxStep,
66 G4double& newSafety); 66 G4double& newSafety);
67 // 67 //
68 // Return linear step for mass geometry 68 // Return linear step for mass geometry
69 69
70 G4double ComputeSafety(const G4ThreeVector& 70 G4double ComputeSafety(const G4ThreeVector& pGlobalPoint,
71 G4double maxRadius = 71 G4double maxRadius = DBL_MAX); // Radius of interest
72 // 72 //
73 // Return safety for all geometries. 73 // Return safety for all geometries.
74 // 74 //
75 // The 2nd argument is the radius of your i 75 // The 2nd argument is the radius of your interest (e.g. maximum displacement )
76 // Giving this you can reduce the average 76 // Giving this you can reduce the average computational cost.
77 // If the second argument is not given, thi 77 // If the second argument is not given, this is the real isotropic safety
78 78
79 void Locate(const G4ThreeVector& pGlobalPoin 79 void Locate(const G4ThreeVector& pGlobalPoint,
80 const G4ThreeVector& direction); 80 const G4ThreeVector& direction);
81 // 81 //
82 // Locate the point for all geometries 82 // Locate the point for all geometries
83 83
84 void ReLocateWithinVolume(const G4ThreeVecto 84 void ReLocateWithinVolume(const G4ThreeVector& pGlobalPoint );
85 // 85 //
86 // Relocate the point in the volume of inter 86 // Relocate the point in the volume of interest
87 87
88 inline void EnableParallelNavigation(G4bool 88 inline void EnableParallelNavigation(G4bool parallel);
89 // 89 //
90 // To have parallel worlds considered, must 90 // To have parallel worlds considered, must be true.
91 // Alternative is to use single (mass) Navi 91 // Alternative is to use single (mass) Navigator directly
92 92
93 void InitialiseNavigator(); 93 void InitialiseNavigator();
94 // 94 //
95 // Check for new navigator for tracking, and 95 // Check for new navigator for tracking, and reinitialise pointer
96 96
97 G4int SetVerboseLevel( G4int lev ) 97 G4int SetVerboseLevel( G4int lev )
98 { G4int oldlv= fVerbose; fVerbose= lev; retu 98 { G4int oldlv= fVerbose; fVerbose= lev; return oldlv;}
99 99
100 inline G4VPhysicalVolume* GetWorldVolume(); 100 inline G4VPhysicalVolume* GetWorldVolume();
101 inline void SetCurrentSafety(G4double val, c 101 inline void SetCurrentSafety(G4double val, const G4ThreeVector& pos);
102 102
103 public: // without description 103 public: // without description
104 104
105 void InitialiseHelper(); 105 void InitialiseHelper();
106 106
107 private: 107 private:
108 108
109 G4PathFinder* fpPathFinder; 109 G4PathFinder* fpPathFinder;
110 G4ITNavigator* fpMassNavigator; 110 G4ITNavigator* fpMassNavigator;
111 G4int fMassNavigatorId; 111 G4int fMassNavigatorId;
112 112
113 G4bool fUseParallelGeometries{false}; 113 G4bool fUseParallelGeometries{false};
114 // Flag whether to use PathFinder or single 114 // Flag whether to use PathFinder or single (mass) Navigator directly
115 G4bool fFirstCall{true}; 115 G4bool fFirstCall{true};
116 // Flag of first call 116 // Flag of first call
117 G4int fVerbose{0}; 117 G4int fVerbose{0};
118 // Whether to print warning in case of move 118 // Whether to print warning in case of move outside safety
119 119
120 public: 120 public:
121 // State used during tracking -- for optimis 121 // State used during tracking -- for optimisation
122 class State 122 class State
123 { 123 {
124 friend class G4ITSafetyHelper; 124 friend class G4ITSafetyHelper;
125 G4ThreeVector fLastSafetyPosition; 125 G4ThreeVector fLastSafetyPosition;
126 G4double fLastSafety{0.0}; 126 G4double fLastSafety{0.0};
127 127
128 public: 128 public:
129 State() : 129 State() :
130 fLastSafetyPosition(0.0,0.0,0.0) 130 fLastSafetyPosition(0.0,0.0,0.0)
131 {} 131 {}
132 132
133 virtual ~State() 133 virtual ~State()
134 = default; 134 = default;
135 }; 135 };
136 136
137 // const G4double fRecomputeFactor; 137 // const G4double fRecomputeFactor;
138 // parameter for further optimisation: 138 // parameter for further optimisation:
139 // if ( move < fact*safety ) do fast recomp 139 // if ( move < fact*safety ) do fast recomputation of safety
140 // End State (tracking) 140 // End State (tracking)
141 }; 141 };
142 142
143 RegisterTrackState(G4ITSafetyHelper, State) 143 RegisterTrackState(G4ITSafetyHelper, State)
144 144
145 // Inline definitions 145 // Inline definitions
146 146
147 inline 147 inline
148 void G4ITSafetyHelper::EnableParallelNavigatio 148 void G4ITSafetyHelper::EnableParallelNavigation(G4bool parallel)
149 { 149 {
150 fUseParallelGeometries = parallel; 150 fUseParallelGeometries = parallel;
151 } 151 }
152 152
153 inline G4VPhysicalVolume* G4ITSafetyHelper::Ge 153 inline G4VPhysicalVolume* G4ITSafetyHelper::GetWorldVolume()
154 { 154 {
155 return fpMassNavigator->GetWorldVolume(); 155 return fpMassNavigator->GetWorldVolume();
156 } 156 }
157 157
158 inline 158 inline
159 void G4ITSafetyHelper::SetCurrentSafety(G4doub 159 void G4ITSafetyHelper::SetCurrentSafety(G4double val, const G4ThreeVector& pos)
160 { 160 {
161 fpTrackState->fLastSafety = val; 161 fpTrackState->fLastSafety = val;
162 fpTrackState->fLastSafetyPosition = pos; 162 fpTrackState->fLastSafetyPosition = pos;
163 } 163 }
164 164
165 #endif 165 #endif
166 166