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