| 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 // $Id: G4ITStepProcessor.hh 64057 2012-10-30 15:04:49Z gcosmo $
26 // 27 //
27 // Author: Mathieu Karamitros << 28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr)
28 <<
29 // The code is developed in the framework of t <<
30 // <<
31 // We would be very happy hearing from you, se <<
32 // <<
33 // In order for Geant4-DNA to be maintained an <<
34 // article citations are crucial. <<
35 // If you use Geant4-DNA chemistry and you pub <<
36 // in addition to the general paper on Geant4- <<
37 // 29 //
38 // Int. J. Model. Simul. Sci. Comput. 1 (2010) << 30 // WARNING : This class is released as a prototype.
>> 31 // It might strongly evolve or even disapear in the next releases.
39 // 32 //
40 // we would be very happy if you could please << 33 // History:
41 // reference papers on chemistry: << 34 // -----------
>> 35 // 10 Oct 2011 M.Karamitros created
42 // 36 //
43 // J. Comput. Phys. 274 (2014) 841-882 << 37 // -------------------------------------------------------------------
44 // Prog. Nucl. Sci. Tec. 2 (2011) 503-508 <<
45 38
46 #ifndef G4ITSTEPPROCESSOR_H 39 #ifndef G4ITSTEPPROCESSOR_H
47 #define G4ITSTEPPROCESSOR_H 40 #define G4ITSTEPPROCESSOR_H
48 41
49 #include "G4ios.hh" // Inclu 42 #include "G4ios.hh" // Include from 'system'
50 #include "globals.hh" // Inclu 43 #include "globals.hh" // Include from 'global'
51 #include "Randomize.hh" // Inclu 44 #include "Randomize.hh" // Include from 'global'
52 45
53 #include "G4LogicalVolume.hh" // Inclu 46 #include "G4LogicalVolume.hh" // Include from 'geometry'
54 #include "G4VPhysicalVolume.hh" // Inclu 47 #include "G4VPhysicalVolume.hh" // Include from 'geometry'
55 #include "G4ProcessManager.hh" // Inclu 48 #include "G4ProcessManager.hh" // Include from 'piim'
56 49
57 #include "G4Track.hh" // Inclu 50 #include "G4Track.hh" // Include from 'track'
58 #include "G4TrackVector.hh" // Inclu 51 #include "G4TrackVector.hh" // Include from 'track'
59 #include "G4TrackStatus.hh" // Inclu 52 #include "G4TrackStatus.hh" // Include from 'track'
60 #include "G4StepStatus.hh" // Inclu 53 #include "G4StepStatus.hh" // Include from 'track'
>> 54 //#include "G4UserSteppingAction.hh" // Include from 'tracking'
>> 55 //#include "G4UserTrackingAction.hh" // Include from 'tracking'
61 #include "G4Step.hh" // Inclu 56 #include "G4Step.hh" // Include from 'track'
62 #include "G4StepPoint.hh" // Inclu 57 #include "G4StepPoint.hh" // Include from 'track'
63 #include "G4TouchableHandle.hh" // Inclu << 58 #include "G4TouchableHandle.hh" // Include from 'geometry'
>> 59 #include "G4TouchableHistoryHandle.hh" // Include from 'geometry'
64 60
65 #include "G4ITStepProcessorState_Lock.hh" <<
66 #include "G4ITLeadingTracks.hh" <<
67 61
68 #include <vector> << 62 #include "G4TrackingInformation.hh"
69 63
>> 64 //class G4Navigator;
70 class G4ITNavigator; 65 class G4ITNavigator;
71 class G4ParticleDefinition; << 66 class G4ParticleDefinition ;
72 class G4ITTrackingManager; 67 class G4ITTrackingManager;
73 class G4IT; 68 class G4IT;
74 class G4TrackingInformation; 69 class G4TrackingInformation;
75 class G4ITTransportation; 70 class G4ITTransportation;
76 class G4VITProcess; 71 class G4VITProcess;
77 class G4VITSteppingVerbose; << 72 typedef class std::vector<int, std::allocator<int> > G4SelectedAtRestDoItVector;
78 class G4ITTrackHolder; << 73 typedef class std::vector<int, std::allocator<int> > G4SelectedAlongStepDoItVector;
79 using G4SelectedAtRestDoItVector = std::vector << 74 typedef class std::vector<int, std::allocator<int> > G4SelectedPostStepDoItVector;
80 using G4SelectedAlongStepDoItVector = std::vec <<
81 using G4SelectedPostStepDoItVector = std::vect <<
82 75
83 //____________________________________________ <<
84 // <<
85 // Members related to ParticleDefinition and n <<
86 // proper to a track <<
87 //____________________________________________ <<
88 struct ProcessGeneralInfo <<
89 { <<
90 G4ProcessVector* fpAtRestDoItVector; <<
91 G4ProcessVector* fpAlongStepDoItVector; <<
92 G4ProcessVector* fpPostStepDoItVector; <<
93 <<
94 G4ProcessVector* fpAtRestGetPhysIntVector; <<
95 G4ProcessVector* fpAlongStepGetPhysIntVector <<
96 G4ProcessVector* fpPostStepGetPhysIntVector; <<
97 // <<
98 // Note: DoItVector has inverse order agains <<
99 // and SelectedPostStepDoItVector. <<
100 // <<
101 // * Max number of processes <<
102 std::size_t MAXofAtRestLoops; <<
103 std::size_t MAXofAlongStepLoops; <<
104 std::size_t MAXofPostStepLoops; <<
105 // Maximum number of processes for each type <<
106 // These depend on the G4ParticleDefinition, <<
107 76
108 // * Transportation process << 77 /**
109 G4ITTransportation* fpTransportation; << 78 * Its role is the same as G4StepManager :
110 }; << 79 * - Find the minimum physical length and corresponding time step
>> 80 * - Step one track BUT on a given time step.
>> 81 */
111 82
112 //____________________________________________ << 83 class G4ITStepProcessor
113 // <<
114 // Members proper to a track <<
115 //____________________________________________ <<
116 class G4ITStepProcessorState : public G4ITStep <<
117 { 84 {
>> 85
118 public: 86 public:
119 G4ITStepProcessorState(); << 87 G4ITStepProcessor();
120 ~G4ITStepProcessorState() override; << 88 virtual ~G4ITStepProcessor();
121 89
122 G4ITStepProcessorState(const G4ITStepProcess << 90 inline void SetPreviousStepTime(G4double);
123 G4ITStepProcessorState& operator=(const G4IT <<
124 91
125 // * Max Number of Process << 92 inline G4Track* GetTrack() {return fpTrack;}
126 G4SelectedAtRestDoItVector fSelectedAtRestDo << 93 inline G4Step* GetStep() {return fpStep;}
127 G4SelectedPostStepDoItVector fSelectedPostSt << 94 inline const G4Step* GetStep() const {return fpStep;}
128 << 95 inline void SetStep(G4Step* val) {fpStep = val;}
129 G4double fPhysicalStep; <<
130 G4double fPreviousStepSize; <<
131 G4double fSafety; <<
132 <<
133 G4StepStatus fStepStatus; <<
134 <<
135 // * Safety <<
136 G4double fProposedSafety; <<
137 // This keeps the minimum safety value propo <<
138 G4ThreeVector fEndpointSafOrigin; <<
139 G4double fEndpointSafety; <<
140 // To get the true safety value at the PostS <<
141 // to subtract the distance to 'endpointSafO <<
142 96
143 G4TouchableHandle fTouchableHandle; << 97 inline G4TrackVector* GetSecondaries() {return fpSecondary;}
144 }; << 98 inline void SetTrackingManager(G4ITTrackingManager* trackMan) {fpTrackingManager = trackMan;}
>> 99 inline G4ITTrackingManager* GetTrackingManager() {return fpTrackingManager;}
145 100
146 /** << 101 virtual void Initialize();
147 * Its role is the same as G4StepManager : << 102 void ForceReInitialization();
148 * - Find the minimum physical length and corr <<
149 * - Step one track BUT on a given time step. <<
150 */ <<
151 103
152 class G4ITStepProcessor << 104 void DefinePhysicalStepLength(G4Track*);
153 { << 105 void Stepping(G4Track*, const double&);
154 friend class G4Scheduler; << 106 void CalculateStep(G4Track*, const double&);
155 public: << 107 void CalculateStep(G4Track*);
156 G4ITStepProcessor(); <<
157 virtual ~G4ITStepProcessor(); <<
158 108
159 inline void SetPreviousStepTime(G4double); << 109 void DoIt(G4Track*,double);
160 110
161 inline G4Track* GetTrack() << 111 void FindTransportationStep();
162 { << 112 void UpdateTrack(G4Track*);
163 return fpTrack; << 113
164 } << 114 inline double GetInteractionTime();
165 inline G4Step* GetStep() << 115 inline const G4Track* GetTrack() const ;
166 { << 116 inline void CleanProcessor();
167 return fpStep; <<
168 } <<
169 inline const G4Step* GetStep() const <<
170 { <<
171 return fpStep; <<
172 } <<
173 inline void SetStep(G4Step* val) <<
174 { <<
175 fpStep = val; <<
176 } <<
177 <<
178 inline G4TrackVector* GetSecondaries() const <<
179 { <<
180 return fpSecondary; <<
181 } <<
182 inline void SetTrackingManager(G4ITTrackingM <<
183 { <<
184 fpTrackingManager = trackMan; <<
185 } <<
186 inline G4ITTrackingManager* GetTrackingManag <<
187 { <<
188 return fpTrackingManager; <<
189 } <<
190 <<
191 //___________________________________ <<
192 <<
193 virtual void Initialize(); <<
194 void ForceReInitialization(); <<
195 <<
196 void ResetLeadingTracks(); <<
197 void PrepareLeadingTracks(); <<
198 <<
199 //___________________________________ <<
200 G4double ComputeInteractionLength(double pre <<
201 void DefinePhysicalStepLength(G4Track*); <<
202 G4double GetILTimeStep() <<
203 { <<
204 return fILTimeStep; <<
205 } <<
206 <<
207 //___________________________________ <<
208 // DoIt <<
209 void DoIt(double timeStep); <<
210 void ExtractDoItData(); <<
211 void Stepping(G4Track*, const double&); <<
212 void FindTransportationStep(); <<
213 //___________________________________ <<
214 <<
215 inline double GetInteractionTime(); <<
216 inline const G4Track* GetTrack() const; <<
217 inline void CleanProcessor(); <<
218 <<
219 std::size_t GetAtRestDoItProcTriggered() con <<
220 { <<
221 return fAtRestDoItProcTriggered; <<
222 } <<
223 <<
224 G4GPILSelection GetGPILSelection() const <<
225 { <<
226 return fGPILSelection; <<
227 } <<
228 <<
229 G4int GetN2ndariesAlongStepDoIt() const <<
230 { <<
231 return fN2ndariesAlongStepDoIt; <<
232 } <<
233 <<
234 G4int GetN2ndariesAtRestDoIt() const <<
235 { <<
236 return fN2ndariesAtRestDoIt; <<
237 } <<
238 <<
239 G4int GetN2ndariesPostStepDoIt() const <<
240 { <<
241 return fN2ndariesPostStepDoIt; <<
242 } <<
243 <<
244 const G4VITProcess* GetCurrentProcess() cons <<
245 { <<
246 return fpCurrentProcess; <<
247 } <<
248 <<
249 G4double GetPhysIntLength() const <<
250 { <<
251 return fPhysIntLength; <<
252 } <<
253 <<
254 std::size_t GetPostStepAtTimeDoItProcTrigger <<
255 { <<
256 return fPostStepAtTimeDoItProcTriggered; <<
257 } <<
258 <<
259 std::size_t GetPostStepDoItProcTriggered() c <<
260 { <<
261 return fPostStepDoItProcTriggered; <<
262 } <<
263 <<
264 const ProcessGeneralInfo* GetCurrentProcessI <<
265 { <<
266 return fpProcessInfo; <<
267 } <<
268 <<
269 const G4ITStepProcessorState* GetProcessorSt <<
270 { <<
271 return fpState; <<
272 } <<
273 <<
274 const G4VParticleChange* GetParticleChange() <<
275 { <<
276 return fpParticleChange; <<
277 } <<
278 <<
279 const G4VPhysicalVolume* GetCurrentVolume() <<
280 { <<
281 return fpCurrentVolume; <<
282 } <<
283 <<
284 G4ForceCondition GetCondition() const <<
285 { <<
286 return fCondition; <<
287 } <<
288 117
289 protected: 118 protected:
>> 119 void SetupGeneralProcessInfo(G4ParticleDefinition*,G4ProcessManager*);
>> 120 void ClearProcessInfo();
>> 121 void SetTrack(G4Track*);
>> 122
>> 123 void GetProcessInfo();
290 124
291 void ExtractILData(); << 125 void SetupMembers();
>> 126 void ResetSecondaries();
>> 127 void InitDefineStep();
292 128
293 void SetupGeneralProcessInfo(G4ParticleDefin << 129 void SetInitialStep();
294 void ClearProcessInfo(); <<
295 void SetTrack(G4Track*); <<
296 <<
297 void GetProcessInfo(); <<
298 <<
299 void SetupMembers(); <<
300 void ResetSecondaries(); <<
301 void InitDefineStep(); <<
302 <<
303 void SetInitialStep(); <<
304 <<
305 void GetAtRestIL(); <<
306 void DoDefinePhysicalStepLength(); <<
307 void DoStepping(); <<
308 void PushSecondaries(); <<
309 <<
310 // void CalculateStep(); <<
311 // void DoCalculateStep(); <<
312 <<
313 // void CloneProcesses(); <<
314 void ActiveOnlyITProcess(); <<
315 void ActiveOnlyITProcess(G4ProcessManager*); <<
316 <<
317 void DealWithSecondaries(G4int&); <<
318 void InvokeAtRestDoItProcs(); <<
319 void InvokeAlongStepDoItProcs(); <<
320 void InvokePostStepDoItProcs(); <<
321 void InvokePSDIP(std::size_t); // <<
322 void InvokeTransportationProc(); <<
323 void SetNavigator(G4ITNavigator *value); <<
324 G4double CalculateSafety(); <<
325 130
326 // Return the estimated safety value at the << 131 void GetAtRestIL();
327 void ApplyProductionCut(G4Track*); << 132 void DoDefinePhysicalStepLength();
>> 133 void DoStepping();
328 134
329 G4ITStepProcessor(const G4ITStepProcessor& o << 135 void CalculateStep();
330 G4ITStepProcessor& operator=(const G4ITStepP << 136 void DoCalculateStep();
>> 137
>> 138 void CloneProcesses();
>> 139 void ActiveOnlyITProcess();
>> 140 void ActiveOnlyITProcess(G4ProcessManager*);
>> 141
>> 142 void DealWithSecondaries(G4int&);
>> 143 void InvokeAtRestDoItProcs();
>> 144 void InvokeAlongStepDoItProcs();
>> 145 void InvokePostStepDoItProcs();
>> 146 void InvokePSDIP(size_t); //
>> 147 void InvokeTransportationProc();
>> 148 void SetNavigator(G4ITNavigator *value);
>> 149 G4double CalculateSafety();
>> 150
>> 151 // Return the estimated safety value at the PostStepPoint
>> 152 void ApplyProductionCut(G4Track*);
>> 153
>> 154
>> 155 G4ITStepProcessor(const G4ITStepProcessor& other);
>> 156 G4ITStepProcessor& operator=(const G4ITStepProcessor& other);
331 157
332 private: 158 private:
333 //__________________________________________ << 159 //________________________________________________
334 // << 160 //
335 // General members << 161 // General members
336 //__________________________________________ << 162 //________________________________________________
337 << 163
338 G4bool fInitialized; << 164 G4bool fInitialized;
339 << 165
340 G4ITTrackingManager* fpTrackingManager; << 166 G4ITTrackingManager* fpTrackingManager;
341 << 167 // G4UserSteppingAction* fpUserSteppingAction;
342 G4double kCarTolerance; << 168
343 // Cached geometrical tolerance on surface << 169 G4double kCarTolerance;
344 << 170 // Cached geometrical tolerance on surface
345 G4ITNavigator* fpNavigator; << 171
346 G4int fStoreTrajectory; << 172 G4ITNavigator* fpNavigator;
347 G4VITSteppingVerbose* fpVerbose; << 173 // G4Navigator* fpNavigator;
348 << 174 G4int fStoreTrajectory;
349 G4ITTrackHolder* fpTrackContainer; << 175 G4int verboseLevel;
350 G4ITLeadingTracks fLeadingTracks; << 176
351 << 177 //________________________________________________
352 //__________________________________________ << 178 //
353 // << 179 // Members used as temporaries (= not proper to a track)
354 // Members used as temporaries (= not proper << 180 //________________________________________________
355 //__________________________________________ << 181
356 << 182 G4double fTimeStep ; // not proper to a track
357 G4double fTimeStep; // not proper to a track << 183 G4double fPreviousTimeStep;
358 G4double fILTimeStep; // proper to a track e << 184 G4TrackVector* fpSecondary ; // get from fpStep at every configuration setup
359 << 185 G4VParticleChange* fpParticleChange;
360 G4double fPreviousTimeStep; << 186
361 G4TrackVector* fpSecondary; // get from fpSt << 187 G4VITProcess* fpCurrentProcess;
362 G4VParticleChange* fpParticleChange; << 188 // The pointer to the process of which DoIt or
363 << 189 // GetPhysicalInteractionLength has been just executed
364 G4VITProcess* fpCurrentProcess; << 190
365 // The pointer to the process of which DoIt << 191 // * Secondaries
366 // GetPhysicalInteractionLength has been jus << 192 G4int fN2ndariesAtRestDoIt;
367 << 193 G4int fN2ndariesAlongStepDoIt;
368 // * Secondaries << 194 G4int fN2ndariesPostStepDoIt;
369 G4int fN2ndariesAtRestDoIt; << 195 // These are the numbers of secondaries generated by the process
370 G4int fN2ndariesAlongStepDoIt; << 196 // just executed.
371 G4int fN2ndariesPostStepDoIt; << 197
372 // These are the numbers of secondaries gene << 198 // * Process selection
373 // just executed. << 199 size_t fAtRestDoItProcTriggered;
374 << 200 size_t fPostStepDoItProcTriggered;
375 // * Process selection << 201 size_t fPostStepAtTimeDoItProcTriggered;
376 std::size_t fAtRestDoItProcTriggered; << 202 // Record the selected process
377 std::size_t fPostStepDoItProcTriggered; << 203
378 std::size_t fPostStepAtTimeDoItProcTriggered << 204 G4ForceCondition fCondition;
379 // Record the selected process << 205 G4GPILSelection fGPILSelection;
380 << 206 // Above three variables are for the method
381 G4ForceCondition fCondition; << 207 // DefinePhysicalStepLength(). To pass these information to
382 G4GPILSelection fGPILSelection; << 208 // the method Verbose, they are kept at here. Need a more
383 // Above three variables are for the method << 209 // elegant mechanism.
384 // DefinePhysicalStepLength(). To pass these << 210
385 // the method Verbose, they are kept at here << 211 G4double fPhysIntLength;
386 // elegant mechanism. << 212 // The minimum physical interaction length over all possible processes
387 << 213
388 G4double fPhysIntLength; << 214 // * Sensitive detector
389 // The minimum physical interaction length o << 215 // G4SteppingControl StepControlFlag;
390 << 216 // G4VSensitiveDetector* fpSensitive;
391 // * Sensitive detector << 217
392 // G4SteppingControl StepControlFlag; << 218 G4VPhysicalVolume* fpCurrentVolume; // Get from fpStep or touchable, keep as member for user interface
393 // G4VSensitiveDetector* fpSensitive; << 219
394 << 220 //________________________________________________
395 G4VPhysicalVolume* fpCurrentVolume; << 221 //
396 // Get from fpStep or touchable, keep as mem << 222 // Members related to ParticleDefinition and not
397 << 223 // proper to a track
398 //__________________________________________ << 224 //________________________________________________
399 // << 225 struct ProcessGeneralInfo
400 // Members related to ParticleDefinition and << 226 {
401 // proper to a track << 227 G4ProcessVector* fpAtRestDoItVector;
402 //__________________________________________ << 228 G4ProcessVector* fpAlongStepDoItVector;
403 << 229 G4ProcessVector* fpPostStepDoItVector;
404 std::map<const G4ParticleDefinition*, Proces << 230
405 ProcessGeneralInfo* fpProcessInfo; << 231 G4ProcessVector* fpAtRestGetPhysIntVector;
406 G4ITTransportation* fpTransportation; << 232 G4ProcessVector* fpAlongStepGetPhysIntVector;
407 << 233 G4ProcessVector* fpPostStepGetPhysIntVector;
408 //__________________________________________ << 234 //
409 // << 235 // Note: DoItVector has inverse order against GetPhysIntVector
410 // Members used for setting up the processor << 236 // and SelectedPostStepDoItVector.
411 //__________________________________________ << 237 //
412 << 238 // * Max Number of Process
413 G4Track* fpTrack; // Set track << 239 size_t MAXofAtRestLoops;
414 G4IT* fpITrack; // Set track << 240 size_t MAXofAlongStepLoops;
415 G4TrackingInformation* fpTrackingInfo; // Se << 241 size_t MAXofPostStepLoops;
>> 242 // Maximum number of processes for each type of process
>> 243 // These depend on the G4ParticleDefinition, so on the track
>> 244
>> 245 // * Transportation process
>> 246 G4ITTransportation* fpTransportation ;
>> 247 };
>> 248
>> 249 std::map<const G4ParticleDefinition*, ProcessGeneralInfo*> fProcessGeneralInfoMap;
>> 250 ProcessGeneralInfo* fpProcessInfo;
>> 251
>> 252 G4ITTransportation* fpTransportation ;
>> 253
>> 254 //________________________________________________
>> 255 //
>> 256 // Members proper to a track
>> 257 //________________________________________________
>> 258 class G4ITStepProcessorState : public G4ITStepProcessorState_Lock
>> 259 {
>> 260 public:
>> 261 G4ITStepProcessorState();
>> 262 virtual ~G4ITStepProcessorState();
>> 263
>> 264 // * Max Number of Process
>> 265 G4SelectedAtRestDoItVector fSelectedAtRestDoItVector;
>> 266 G4SelectedPostStepDoItVector fSelectedPostStepDoItVector;
>> 267
>> 268 G4double fPhysicalStep;
>> 269 G4double fPreviousStepSize;
>> 270 G4double fSafety;
>> 271
>> 272 G4StepStatus fStepStatus;
>> 273
>> 274 // * Safety
>> 275 G4double proposedSafety;
>> 276 // This keeps the minimum safety value proposed by AlongStepGPILs.
>> 277 G4ThreeVector endpointSafOrigin;
>> 278 G4double endpointSafety;
>> 279 // To get the true safety value at the PostStepPoint, you have
>> 280 // to subtract the distance to 'endpointSafOrigin' from this value.
>> 281
>> 282 G4TouchableHandle fTouchableHandle;
>> 283 private :
>> 284 G4ITStepProcessorState(const G4ITStepProcessorState&);
>> 285 G4ITStepProcessorState& operator=(const G4ITStepProcessorState&);
>> 286 };
>> 287
>> 288 //________________________________________________
>> 289 //
>> 290 // Members used for configurating the processor
>> 291 //________________________________________________
>> 292
>> 293 G4Track* fpTrack; // Set track
>> 294 G4IT* fpITrack ; // Set track
>> 295 G4TrackingInformation* fpTrackingInfo ; // Set track
416 296
417 G4ITStepProcessorState* fpState; // SetupMem << 297 G4ITStepProcessorState* fpState; // SetupMembers or InitDefineStep
418 G4Step* fpStep; // Set track or InitDefineSt << 298 G4Step* fpStep; // Set track or InitDefineStep
419 299
420 G4StepPoint* fpPreStepPoint; // SetupMembers << 300 G4StepPoint* fpPreStepPoint; // SetupMembers
421 G4StepPoint* fpPostStepPoint; // SetupMember << 301 G4StepPoint* fpPostStepPoint; // SetupMembers
422 }; 302 };
423 303
424 //____________________________________________ <<
425 <<
426 inline void G4ITStepProcessor::SetPreviousStep 304 inline void G4ITStepProcessor::SetPreviousStepTime(G4double previousTimeStep)
427 { 305 {
428 fPreviousTimeStep = previousTimeStep; << 306 fPreviousTimeStep = previousTimeStep;
429 } 307 }
430 308
431 //____________________________________________ <<
432 <<
433 inline const G4Track* G4ITStepProcessor::GetTr 309 inline const G4Track* G4ITStepProcessor::GetTrack() const
434 { 310 {
435 return fpTrack; << 311 return fpTrack;
436 } 312 }
437 313
438 //____________________________________________ <<
439 <<
440 inline G4double G4ITStepProcessor::CalculateSa 314 inline G4double G4ITStepProcessor::CalculateSafety()
441 { 315 {
442 return std::max(fpState->fEndpointSafety - ( << 316 return std::max( fpState->endpointSafety -
443 - fpPostStepPoint->GetPo << 317 (fpState->endpointSafOrigin - fpPostStepPoint->GetPosition()).mag(),
444 kCarTolerance); << 318 kCarTolerance );
445 } 319 }
446 320
447 //____________________________________________ <<
448 <<
449 inline void G4ITStepProcessor::SetNavigator(G4 321 inline void G4ITStepProcessor::SetNavigator(G4ITNavigator *value)
450 { 322 {
451 fpNavigator = value; << 323 fpNavigator = value;
452 } 324 }
453 325
454 //____________________________________________ <<
455 <<
456 inline void G4ITStepProcessor::CleanProcessor( 326 inline void G4ITStepProcessor::CleanProcessor()
457 { 327 {
458 fTimeStep = DBL_MAX; << 328 fTimeStep = DBL_MAX ;
459 fPhysIntLength = DBL_MAX; << 329 fPhysIntLength = DBL_MAX;
460 330
461 fpState = nullptr; << 331 fpState = 0;
462 fpTrack = nullptr; << 332 fpTrack = 0;
463 fpTrackingInfo = nullptr; << 333 fpTrackingInfo = 0 ;
464 fpITrack = nullptr; << 334 fpITrack = 0;
465 fpStep = nullptr; << 335 fpStep = 0;
466 fpPreStepPoint = nullptr; << 336 fpPreStepPoint = 0;
467 fpPostStepPoint = nullptr; << 337 fpPostStepPoint = 0;
468 << 338
469 fpParticleChange = nullptr; << 339 fpParticleChange = 0;
470 << 340
471 fpCurrentVolume = nullptr; << 341 fpCurrentVolume = 0;
472 // fpSensitive = 0; << 342 // fpSensitive = 0;
473 << 343
474 fpSecondary = nullptr; << 344 fpSecondary = 0 ;
475 << 345
476 fpTransportation = nullptr; << 346 fpTransportation = 0;
477 << 347
478 fpCurrentProcess= nullptr; << 348 fpCurrentProcess= 0;
479 fpProcessInfo = nullptr; << 349 fpProcessInfo = 0;
480 << 350
481 fAtRestDoItProcTriggered = INT_MAX; << 351 fAtRestDoItProcTriggered = INT_MAX;
482 fPostStepDoItProcTriggered = INT_MAX; << 352 fPostStepDoItProcTriggered = INT_MAX;
483 fPostStepAtTimeDoItProcTriggered = INT_MAX; << 353 fPostStepAtTimeDoItProcTriggered = INT_MAX;
484 fGPILSelection = NotCandidateForSelection; << 354 fGPILSelection = NotCandidateForSelection ;
485 fCondition = NotForced; << 355 fCondition = NotForced;
486 } 356 }
487 357
488 //____________________________________________ 358 //______________________________________________________________________________
489 <<
490 inline double G4ITStepProcessor::GetInteractio 359 inline double G4ITStepProcessor::GetInteractionTime()
491 { 360 {
492 return fTimeStep; << 361 return fTimeStep ;
493 } 362 }
>> 363
494 364
495 #endif // G4ITSTEPPROCESSOR_H 365 #endif // G4ITSTEPPROCESSOR_H
496 366