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