| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 // Author: Mathieu Karamitros
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 //
38 // Int. J. Model. Simul. Sci. Comput. 1 (2010)
39 //
40 // we would be very happy if you could please
41 // reference papers on chemistry:
42 //
43 // J. Comput. Phys. 274 (2014) 841-882
44 // Prog. Nucl. Sci. Tec. 2 (2011) 503-508
45
46 #ifndef G4ITSTEPPROCESSOR_H
47 #define G4ITSTEPPROCESSOR_H
48
49 #include "G4ios.hh" // Inclu
50 #include "globals.hh" // Inclu
51 #include "Randomize.hh" // Inclu
52
53 #include "G4LogicalVolume.hh" // Inclu
54 #include "G4VPhysicalVolume.hh" // Inclu
55 #include "G4ProcessManager.hh" // Inclu
56
57 #include "G4Track.hh" // Inclu
58 #include "G4TrackVector.hh" // Inclu
59 #include "G4TrackStatus.hh" // Inclu
60 #include "G4StepStatus.hh" // Inclu
61 #include "G4Step.hh" // Inclu
62 #include "G4StepPoint.hh" // Inclu
63 #include "G4TouchableHandle.hh" // Inclu
64
65 #include "G4ITStepProcessorState_Lock.hh"
66 #include "G4ITLeadingTracks.hh"
67
68 #include <vector>
69
70 class G4ITNavigator;
71 class G4ParticleDefinition;
72 class G4ITTrackingManager;
73 class G4IT;
74 class G4TrackingInformation;
75 class G4ITTransportation;
76 class G4VITProcess;
77 class G4VITSteppingVerbose;
78 class G4ITTrackHolder;
79 using G4SelectedAtRestDoItVector = std::vector
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
146 /**
147 * Its role is the same as G4StepManager :
148 * - Find the minimum physical length and corr
149 * - Step one track BUT on a given time step.
150 */
151
152 class G4ITStepProcessor
153 {
154 friend class G4Scheduler;
155 public:
156 G4ITStepProcessor();
157 virtual ~G4ITStepProcessor();
158
159 inline void SetPreviousStepTime(G4double);
160
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
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
289 protected:
290
291 void ExtractILData();
292
293 void SetupGeneralProcessInfo(G4ParticleDefin
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
326 // Return the estimated safety value at the
327 void ApplyProductionCut(G4Track*);
328
329 G4ITStepProcessor(const G4ITStepProcessor& o
330 G4ITStepProcessor& operator=(const G4ITStepP
331
332 private:
333 //__________________________________________
334 //
335 // General members
336 //__________________________________________
337
338 G4bool fInitialized;
339
340 G4ITTrackingManager* fpTrackingManager;
341
342 G4double kCarTolerance;
343 // Cached geometrical tolerance on surface
344
345 G4ITNavigator* fpNavigator;
346 G4int fStoreTrajectory;
347 G4VITSteppingVerbose* fpVerbose;
348
349 G4ITTrackHolder* fpTrackContainer;
350 G4ITLeadingTracks fLeadingTracks;
351
352 //__________________________________________
353 //
354 // Members used as temporaries (= not proper
355 //__________________________________________
356
357 G4double fTimeStep; // not proper to a track
358 G4double fILTimeStep; // proper to a track e
359
360 G4double fPreviousTimeStep;
361 G4TrackVector* fpSecondary; // get from fpSt
362 G4VParticleChange* fpParticleChange;
363
364 G4VITProcess* fpCurrentProcess;
365 // The pointer to the process of which DoIt
366 // GetPhysicalInteractionLength has been jus
367
368 // * Secondaries
369 G4int fN2ndariesAtRestDoIt;
370 G4int fN2ndariesAlongStepDoIt;
371 G4int fN2ndariesPostStepDoIt;
372 // These are the numbers of secondaries gene
373 // just executed.
374
375 // * Process selection
376 std::size_t fAtRestDoItProcTriggered;
377 std::size_t fPostStepDoItProcTriggered;
378 std::size_t fPostStepAtTimeDoItProcTriggered
379 // Record the selected process
380
381 G4ForceCondition fCondition;
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
388 G4double fPhysIntLength;
389 // The minimum physical interaction length o
390
391 // * Sensitive detector
392 // G4SteppingControl StepControlFlag;
393 // G4VSensitiveDetector* fpSensitive;
394
395 G4VPhysicalVolume* fpCurrentVolume;
396 // Get from fpStep or touchable, keep as mem
397
398 //__________________________________________
399 //
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
408 //__________________________________________
409 //
410 // Members used for setting up the processor
411 //__________________________________________
412
413 G4Track* fpTrack; // Set track
414 G4IT* fpITrack; // Set track
415 G4TrackingInformation* fpTrackingInfo; // Se
416
417 G4ITStepProcessorState* fpState; // SetupMem
418 G4Step* fpStep; // Set track or InitDefineSt
419
420 G4StepPoint* fpPreStepPoint; // SetupMembers
421 G4StepPoint* fpPostStepPoint; // SetupMember
422 };
423
424 //____________________________________________
425
426 inline void G4ITStepProcessor::SetPreviousStep
427 {
428 fPreviousTimeStep = previousTimeStep;
429 }
430
431 //____________________________________________
432
433 inline const G4Track* G4ITStepProcessor::GetTr
434 {
435 return fpTrack;
436 }
437
438 //____________________________________________
439
440 inline G4double G4ITStepProcessor::CalculateSa
441 {
442 return std::max(fpState->fEndpointSafety - (
443 - fpPostStepPoint->GetPo
444 kCarTolerance);
445 }
446
447 //____________________________________________
448
449 inline void G4ITStepProcessor::SetNavigator(G4
450 {
451 fpNavigator = value;
452 }
453
454 //____________________________________________
455
456 inline void G4ITStepProcessor::CleanProcessor(
457 {
458 fTimeStep = DBL_MAX;
459 fPhysIntLength = DBL_MAX;
460
461 fpState = nullptr;
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 }
487
488 //____________________________________________
489
490 inline double G4ITStepProcessor::GetInteractio
491 {
492 return fTimeStep;
493 }
494
495 #endif // G4ITSTEPPROCESSOR_H
496