| 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 //
>> 27 // $Id: G4PropagatorInField.hh,v 1.19 2009/11/13 17:34:26 japost Exp $
>> 28 // GEANT4 tag $Name: geant4-09-03 $
>> 29 //
>> 30 //
26 // Class G4PropagatorInField 31 // Class G4PropagatorInField
27 // 32 //
28 // class description: 33 // class description:
29 // 34 //
30 // This class performs the navigation/propagat 35 // This class performs the navigation/propagation of a particle/track
31 // in a magnetic field. The field is in genera 36 // in a magnetic field. The field is in general non-uniform.
32 // For the calculation of the path, it relies 37 // For the calculation of the path, it relies on the class G4ChordFinder.
>> 38 //
>> 39 // Key Method: ComputeStep(..)
33 40
34 // History: 41 // History:
35 // ------- 42 // -------
36 // 25.10.96 John Apostolakis, design and impl 43 // 25.10.96 John Apostolakis, design and implementation
37 // 25.03.97 John Apostolakis, adaptation for 44 // 25.03.97 John Apostolakis, adaptation for G4Transportation and cleanup
38 // 8.11.02 John Apostolakis, changes to enab 45 // 8.11.02 John Apostolakis, changes to enable use of safety in intersecting
39 // ------------------------------------------- 46 // ---------------------------------------------------------------------------
>> 47
40 #ifndef G4PropagatorInField_hh 48 #ifndef G4PropagatorInField_hh
41 #define G4PropagatorInField_hh 1 49 #define G4PropagatorInField_hh 1
42 50
43 #include "G4Types.hh" 51 #include "G4Types.hh"
44 52
45 #include <vector> 53 #include <vector>
46 54
47 #include "G4FieldTrack.hh" 55 #include "G4FieldTrack.hh"
48 #include "G4FieldManager.hh" 56 #include "G4FieldManager.hh"
49 #include "G4VIntersectionLocator.hh" 57 #include "G4VIntersectionLocator.hh"
50 58
51 class G4ChordFinder; 59 class G4ChordFinder;
52 60
53 class G4Navigator; 61 class G4Navigator;
54 class G4VPhysicalVolume; 62 class G4VPhysicalVolume;
55 class G4VCurvedTrajectoryFilter; 63 class G4VCurvedTrajectoryFilter;
56 64
57 class G4PropagatorInField 65 class G4PropagatorInField
58 { 66 {
59 67
60 public: // with description 68 public: // with description
61 69
62 G4PropagatorInField( G4Navigator* theNaviga << 70 G4PropagatorInField( G4Navigator *theNavigator,
63 G4FieldManager* detect << 71 G4FieldManager *detectorFieldMgr,
64 G4VIntersectionLocator << 72 G4VIntersectionLocator *vLocator=0 );
65 ~G4PropagatorInField(); 73 ~G4PropagatorInField();
66 74
67 G4double ComputeStep( G4FieldTrack& pFieldT << 75 G4double ComputeStep( G4FieldTrack &pFieldTrack,
68 G4double pCurrentProp << 76 G4double pCurrentProposedStepLength,
69 G4double& pNewSafety, << 77 G4double &pNewSafety,
70 G4VPhysicalVolume* pP << 78 G4VPhysicalVolume *pPhysVol=0 );
71 G4bool canRelaxDeltaC <<
72 // Compute the next geometric Step 79 // Compute the next geometric Step
73 80
74 inline G4ThreeVector EndPosition() const; << 81 inline G4ThreeVector EndPosition() const;
75 inline G4ThreeVector EndMomentumDir() const << 82 inline G4ThreeVector EndMomentumDir() const;
76 inline G4bool IsParticleLooping() co << 83 inline G4bool IsParticleLooping() const;
77 // Return the state after the Step 84 // Return the state after the Step
78 85
79 inline G4double GetEpsilonStep() const; << 86 inline G4double GetEpsilonStep() const;
80 // Relative accuracy for current Step (Ca 87 // Relative accuracy for current Step (Calc.)
81 inline void SetEpsilonStep(G4double new << 88 inline void SetEpsilonStep(G4double newEps);
82 // The ratio DeltaOneStep()/h_current_ste 89 // The ratio DeltaOneStep()/h_current_step
83 90
84 G4FieldManager* FindAndSetFieldManager(G4VP << 91 inline void SetChargeMomentumMass( G4double charge, // in e+ units
>> 92 G4double momentum, // in Geant4 units
>> 93 G4double pMass );
>> 94 // Inform this and all associated classes of q, p, m
>> 95
>> 96 G4FieldManager* FindAndSetFieldManager(G4VPhysicalVolume* pCurrentPhysVol);
85 // Set (and return) the correct field man 97 // Set (and return) the correct field manager (global or local),
86 // if it exists. << 98 // if it exists.
87 // Should be called before ComputeStep is 99 // Should be called before ComputeStep is called;
88 // Currently, ComputeStep will call it, i << 100 // - currently, ComputeStep will call it, if it has not been called.
89 101
90 inline G4ChordFinder* GetChordFinder(); 102 inline G4ChordFinder* GetChordFinder();
91 103
92 G4int SetVerboseLevel( G4int verbose << 104 G4int SetVerboseLevel( G4int verbose );
93 inline G4int GetVerboseLevel() const; << 105 inline G4int GetVerboseLevel() const;
94 inline G4int Verbose() const; << 106 inline G4int Verbose() const;
95 inline void CheckMode(G4bool mode); << 107
96 << 108 inline G4int GetMaxLoopCount() const;
97 inline void SetVerboseTrace( G4bool enabl << 109 inline void SetMaxLoopCount( G4int new_max );
98 inline G4bool GetVerboseTrace(); << 110 // A maximum for the number of steps that a (looping) particle can take.
99 // Tracing key parts of Compute Step << 111
100 << 112 void printStatus( const G4FieldTrack& startFT,
101 inline G4int GetMaxLoopCount() const; << 113 const G4FieldTrack& currentFT,
102 inline void SetMaxLoopCount( G4int new_max << 114 G4double requestStep,
103 // A maximum for the number of substeps t << 115 G4double safety,
104 // Above this number it is signaled as << 116 G4int step,
105 << 117 G4VPhysicalVolume* startVolume);
106 void printStatus( const G4FieldTrack& <<
107 const G4FieldTrack& <<
108 G4double <<
109 G4double <<
110 G4int <<
111 G4VPhysicalVolume* <<
112 // Print Method - useful mostly for debug 118 // Print Method - useful mostly for debugging.
113 119
114 inline G4FieldTrack GetEndState() const; 120 inline G4FieldTrack GetEndState() const;
115 121
116 inline G4double GetMinimumEpsilonStep() con << 122 inline G4double GetMinimumEpsilonStep() const; // Min for relative accuracy
117 inline void SetMinimumEpsilonStep( G4do << 123 inline void SetMinimumEpsilonStep( G4double newEpsMin ); // of any step
118 inline G4double GetMaximumEpsilonStep() con << 124 inline G4double GetMaximumEpsilonStep() const;
119 inline void SetMaximumEpsilonStep( G4do << 125 inline void SetMaximumEpsilonStep( G4double newEpsMax );
120 // The 4 above methods are now obsolescen << 126 inline void SetLargestAcceptableStep( G4double newBigDist );
>> 127 inline G4double GetLargestAcceptableStep();
>> 128 // The 6 above methods are now obsolescent but *for now* will work
121 // They are being replaced by same-name m 129 // They are being replaced by same-name methods in G4FieldManager,
122 // allowing the specialisation in differe 130 // allowing the specialisation in different volumes.
123 // Their new behaviour is to change the v 131 // Their new behaviour is to change the values for the global field
124 // manager 132 // manager
125 133
126 void SetLargestAcceptableStep( G4double <<
127 G4double GetLargestAcceptableStep(); <<
128 void ResetLargestAcceptableStep(); <<
129 // Obtain / change the size of the larges <<
130 // Reset method uses the world volume's <<
131 <<
132 G4double GetMaxStepSizeMultiplier(); <<
133 void SetMaxStepSizeMultiplier(G4double <<
134 // Control extra Multiplier parameter for <<
135 G4double GetMinBigDistance(); <<
136 void SetMinBigDistance(G4double val); <<
137 // Control minimum 'directional' distance <<
138 <<
139 void SetTrajectoryFilter(G4VCurvedTrajector 134 void SetTrajectoryFilter(G4VCurvedTrajectoryFilter* filter);
140 // Set the filter that examines & stores 135 // Set the filter that examines & stores 'intermediate'
141 // curved trajectory points. Currently o << 136 // curved trajectory points. Currently only position is stored.
142 137
143 std::vector<G4ThreeVector>* GimmeTrajectory 138 std::vector<G4ThreeVector>* GimmeTrajectoryVectorAndForgetIt() const;
144 // Access the points which have passed by 139 // Access the points which have passed by the filter.
145 // Responsibility for deleting the points 140 // Responsibility for deleting the points lies with the client.
146 // This method MUST BE called exactly ONC 141 // This method MUST BE called exactly ONCE per step.
147 142
148 void ClearPropagatorState(); 143 void ClearPropagatorState();
149 // Clear all the State of this class and 144 // Clear all the State of this class and its current associates
150 // --> the current field manager & chord << 145 // --> the current field manager & chord finder will also be called
151 146
152 inline void SetDetectorFieldManager( G4Fiel 147 inline void SetDetectorFieldManager( G4FieldManager* newGlobalFieldManager );
153 // Update this (dangerous) state -- for t 148 // Update this (dangerous) state -- for the time being
154 149
155 inline void SetUseSafetyForOptimization( 150 inline void SetUseSafetyForOptimization( G4bool );
156 inline G4bool GetUseSafetyForOptimization() 151 inline G4bool GetUseSafetyForOptimization();
157 // Toggle & view parameter for using safe 152 // Toggle & view parameter for using safety to discard
158 // unneccesary calls to navigator (thus ' << 153 // unneccesary calls to navigator (thus 'optimising' performance)
159 inline G4bool IntersectChord( const G4Three << 154 inline G4bool IntersectChord( G4ThreeVector StartPointA,
160 const G4Three << 155 G4ThreeVector EndPointB,
161 G4doubl << 156 G4double &NewSafety,
162 G4doubl << 157 G4double &LinearStepLength,
163 G4Three << 158 G4ThreeVector &IntersectionPoint);
164 // Intersect the chord from StartPointA t 159 // Intersect the chord from StartPointA to EndPointB
165 // and return whether an intersection occ 160 // and return whether an intersection occurred
166 // NOTE: Safety is changed! << 161 // NOTE : SAFETY IS CHANGED
167 162
168 inline G4bool IsFirstStepInVolume(); <<
169 inline G4bool IsLastStepInVolume(); <<
170 inline void PrepareNewTrack(); <<
171 <<
172 inline G4VIntersectionLocator* GetIntersect 163 inline G4VIntersectionLocator* GetIntersectionLocator();
173 inline void SetIntersectionLocator(G4VInter << 164 inline void SetIntersectionLocator(G4VIntersectionLocator *pLocator );
174 // Change or get the object which calcula 165 // Change or get the object which calculates the exact
175 // intersection point with the next bound << 166 // intersection point with the next boundary
176 << 167
177 inline G4int GetIterationsToIncreaseChordDi <<
178 inline void SetIterationsToIncreaseChordDi <<
179 // Control the parameter which enables th <<
180 // which ensures that chord segments ar <<
181 // their sagitta is small than delta-ch <<
182 // The Set method increases the value of <<
183 // doubling it once the number of itera <<
184 // value of 'IncreaseChordDistanceThres <<
185 // again every time the iteration count <<
186 // value. <<
187 // Note: delta-chord is reset to its orig <<
188 // each call to ComputeStep. <<
189 <<
190 public: // without description 168 public: // without description
191 169
192 inline G4double GetDeltaIntersection() cons << 170 inline G4double GetDeltaIntersection() const;
193 inline G4double GetDeltaOneStep() const; << 171 inline G4double GetDeltaOneStep() const;
194 172
195 inline G4FieldManager* GetCurrentFieldManag << 173 inline G4FieldManager* GetCurrentFieldManager();
196 inline G4EquationOfMotion* GetCurrentEquati << 174 inline void SetNavigatorForPropagating( G4Navigator *SimpleOrMultiNavigator );
197 // Auxiliary methods - their results can << 175 inline G4Navigator* GetNavigatorForPropagating();
198 <<
199 inline void SetNavigatorForPropagating(G4Na <<
200 inline G4Navigator* GetNavigatorForPropagat <<
201 176
202 inline void SetThresholdNoZeroStep( G4int n 177 inline void SetThresholdNoZeroStep( G4int noAct,
203 G4int n 178 G4int noHarsh,
204 G4int n 179 G4int noAbandon );
205 inline G4int GetThresholdNoZeroSteps( G4int 180 inline G4int GetThresholdNoZeroSteps( G4int i );
206 181
207 inline G4double GetZeroStepThreshold(); << 182 inline G4double GetZeroStepThreshold();
208 inline void SetZeroStepThreshold( G4dou << 183 inline void SetZeroStepThreshold( G4double newLength );
209 << 184
210 void RefreshIntersectionLocator(); 185 void RefreshIntersectionLocator();
211 // Update the Locator with parameters fro 186 // Update the Locator with parameters from this class
212 // and from current field manager << 187 // and from current field manager
213 188
214 protected: // without description << 189 protected: // with description
215 190
216 void PrintStepLengthDiagnostic( G4double 191 void PrintStepLengthDiagnostic( G4double currentProposedStepLength,
217 G4double 192 G4double decreaseFactor,
218 G4double 193 G4double stepTrial,
219 const G4FieldTrac 194 const G4FieldTrack& aFieldTrack);
220 <<
221 void ReportLoopingParticle( G4int count, G <<
222 G4double stepRe <<
223 const G4ThreeVe <<
224 G4VPhysicalVolu <<
225 void ReportStuckParticle(G4int noZeroSteps, <<
226 G4double lastTried <<
227 <<
228 private: 195 private:
229 196
230 // ---------------------------------------- 197 // ----------------------------------------------------------------------
231 // DATA Members 198 // DATA Members
232 // ---------------------------------------- 199 // ----------------------------------------------------------------------
233 200
234 // ======================================= << 201 G4FieldManager *fDetectorFieldMgr;
235 // INVARIANTS - Must not change during tra << 202 // The Field Manager of the whole Detector. (default)
>> 203
>> 204 G4FieldManager *fCurrentFieldMgr;
>> 205 // The Field Manager of the current volume (may be the one above.)
>> 206
>> 207 G4Navigator *fNavigator;
>> 208
>> 209 // STATE information
>> 210 // -----------------
236 211
237 // ** PARAMETERS ----------- << 212 G4double fEpsilonStep;
238 G4int fMax_loop_count = 1000; << 213 // Relative accuracy for current Step (Calc.)
>> 214
>> 215 G4FieldTrack End_PointAndTangent;
>> 216 // End point storage
>> 217
>> 218 G4bool fParticleIsLooping;
>> 219
>> 220 G4int fVerboseLevel;
>> 221 // For debuging purposes
>> 222
>> 223 G4int fMax_loop_count;
239 // Limit for the number of sub-steps take 224 // Limit for the number of sub-steps taken in one call to ComputeStep
240 G4int fIncreaseChordDistanceThreshold = 100 <<
241 G4bool fUseSafetyForOptimisation = true; <<
242 // (false) is less sensitive to incorrect <<
243 225
244 // Thresholds for identifying "abnormal" c << 226 // Variables to keep track of "abnormal" case - which causes loop
245 // 227 //
246 G4int fActionThreshold_NoZeroSteps = 2; << 228 G4int fNoZeroStep; // Counter of zeroStep
247 G4int fSevereActionThreshold_NoZeroSteps = << 229 G4int fActionThreshold_NoZeroSteps; // Threshold: above this - act
248 G4int fAbandonThreshold_NoZeroSteps = 50; << 230 G4int fSevereActionThreshold_NoZeroSteps; // Threshold to act harshly
249 G4double fZeroStepThreshold = 0.0; << 231 G4int fAbandonThreshold_NoZeroSteps; // Threshold to abandon
250 // Threshold *length* for counting of tin << 232
251 << 233 G4double fFull_CurveLen_of_LastAttempt;
252 // Parameters related to handling of very l << 234 G4double fLast_ProposedStepLength;
253 // occur typically in large volumes with << 235 G4double fLargestAcceptableStep;
254 G4double fLargestAcceptableStep; << 236
255 // Maximum size of a step - for optimizat << 237 G4double fCharge, fInitialMomentumModulus, fMass;
256 G4double fMaxStepSizeMultiplier = 3; << 238
257 // Multiplier for directional exit distan << 239 G4ThreeVector fPreviousSftOrigin;
258 G4double fMinBigDistance= 100. ; // * CLHEP << 240 G4double fPreviousSafety;
259 // Minimum distance added to directional << 241 G4bool fUseSafetyForOptimisation;
260 // ** End of PARAMETERS ----- << 242 // Last safety origin & value: for optimisation
261 << 243
262 G4double kCarTolerance; << 244 G4bool fSetFieldMgr;
263 // Geometrical tolerance defining surfa << 245 // Flag whether field manager has been set for the current step
264 <<
265 G4bool fAllocatedLocator; <<
266 <<
267 // --------------------------------------- <<
268 // ** Dependent Objects - to which work is <<
269 246
270 G4FieldManager* fDetectorFieldMgr; << 247 G4double kCarTolerance;
271 // The Field Manager of the whole Dete << 248 // Geometrical tolerance defining surface thickness
>> 249 G4double fZeroStepThreshold;
>> 250 // Threshold for counting of tiny or 'zero' steps
>> 251
>> 252 G4VIntersectionLocator *fIntersectionLocator;
>> 253 G4bool fAllocatedLocator;
>> 254 // Used to Intersection Locator
272 255
273 G4VIntersectionLocator* fIntersectionLocato << 256 private:
274 // Refines candidate intersection <<
275 257
276 G4VCurvedTrajectoryFilter* fpTrajectoryFilt << 258 G4VCurvedTrajectoryFilter* fpTrajectoryFilter;
277 // The filter encapsulates the algorithm 259 // The filter encapsulates the algorithm which selects which
278 // intermediate points should be stored i 260 // intermediate points should be stored in a trajectory.
279 // When it is NULL, no intermediate point 261 // When it is NULL, no intermediate points will be stored.
280 // Else PIF::ComputeStep must submit (all 262 // Else PIF::ComputeStep must submit (all) intermediate
281 // points it calculates, to this filter. 263 // points it calculates, to this filter. (jacek 04/11/2002)
282 <<
283 G4Navigator* fNavigator; <<
284 // Set externally - only by tracking / ru <<
285 // <<
286 // ** End of Dependent Objects ----------- <<
287 <<
288 // End of INVARIANTS <<
289 // ======================================= <<
290 <<
291 // STATE information <<
292 // ----------------- <<
293 G4FieldManager* fCurrentFieldMgr; <<
294 // The Field Manager of the current volu <<
295 G4bool fSetFieldMgr = false; // Has it bee <<
296 <<
297 // Parameters of current step <<
298 G4double fEpsilonStep; // Relati <<
299 G4FieldTrack End_PointAndTangent; // End po <<
300 G4bool fParticleIsLooping = false; <<
301 G4int fNoZeroStep = 0; // Count <<
302 <<
303 // State used for Optimisation <<
304 G4double fFull_CurveLen_of_LastAttempt = -1 <<
305 G4double fLast_ProposedStepLength = -1; <<
306 // Previous step information -- for use i <<
307 G4ThreeVector fPreviousSftOrigin; <<
308 G4double fPreviousSafety = 0.0; <<
309 // Last safety origin & value: for optimi <<
310 <<
311 G4int fVerboseLevel = 0; <<
312 G4bool fVerbTracePiF = false; <<
313 G4bool fCheck = false; <<
314 // For debugging purposes <<
315 <<
316 G4bool fFirstStepInVolume = true; <<
317 G4bool fLastStepInVolume = true; <<
318 G4bool fNewTrack = true; <<
319 }; 264 };
320 265
321 // Inline methods << 266 // ********************************************************************
322 // << 267 // Inline methods.
>> 268 // ********************************************************************
>> 269
323 #include "G4PropagatorInField.icc" 270 #include "G4PropagatorInField.icc"
324 271
325 #endif 272 #endif
326 273