| 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 G4Scheduler_h
47 #define G4Scheduler_h
48
49 #include "G4ITModelHandler.hh"
50 #include "G4ITReaction.hh"
51 #include "G4ITStepStatus.hh"
52 #include "G4ITTrackHolder.hh"
53 #include "G4VScavengerMaterial.hh"
54 #include "G4VStateDependent.hh"
55 #include "globals.hh"
56
57 #include <G4VScheduler.hh>
58
59 #include <map>
60 #include <memory>
61 #include <vector>
62
63 class G4ITTrackingManager;
64 class G4ITModelProcessor;
65 class G4ITStepProcessor;
66 class G4Track;
67 class G4UserTimeStepAction;
68 class G4SchedulerMessenger;
69 class G4ITTrackingInteractivity;
70 class G4ITGun;
71
72 #ifndef compTrackPerID__
73 # define compTrackPerID__
74 struct compTrackPerID
75 {
76 G4bool operator()(G4Track* rhs, G4Track* l
77 {
78 return rhs->GetTrackID() < lhs->GetTrack
79 }
80 };
81 #endif
82
83 /**
84 * G4Scheduler synchronizes (in time) track st
85 */
86 class G4Scheduler : public G4VScheduler, publi
87 {
88 protected:
89 ~G4Scheduler() override;
90
91 public:
92 G4Scheduler(const G4Scheduler&) = delete;
93 G4Scheduler& operator=(const G4Scheduler&)
94
95 static G4Scheduler* Instance();
96 /** DeleteInstance should be used instead
97 * of the destructor
98 */
99 static void DeleteInstance();
100 G4bool Notify(G4ApplicationState requested
101
102 void RegisterModel(G4VITStepModel*, G4doub
103
104 void Initialize() override;
105 void ForceReinitialization();
106 inline G4bool IsInitialized();
107 inline G4bool IsRunning() override { retur
108 void Reset() override;
109 void Process() override;
110 void ClearList();
111
112 inline void SetGun(G4ITGun*) override;
113 inline G4ITGun* GetGun();
114
115 inline void Stop();
116 void Clear();
117
118 // To be called only in UserReactionAction
119 // after fRunning flag has been turned off
120 // This is not done automatically before U
121 // is called in case one would like to acc
122 void EndTracking();
123
124 void SetEndTime(const G4double) override;
125
126 /* Two tracks below the time tolerance are
127 * in the same time slice
128 */
129 inline void SetTimeTolerance(G4double) ove
130 inline G4double GetTimeTolerance() const o
131
132 inline void SetMaxZeroTimeAllowed(G4int) o
133 inline G4int GetMaxZeroTimeAllowed() const
134
135 inline G4ITModelHandler* GetModelHandler()
136
137 inline void SetTimeSteps(std::map<G4double
138 inline void AddTimeStep(G4double, G4double
139 inline void SetDefaultTimeStep(G4double) o
140 G4double GetLimitingTimeStep() const overr
141 inline G4int GetNbSteps() const override;
142 inline void SetMaxNbSteps(G4int) override;
143 inline G4int GetMaxNbSteps() const overrid
144 inline G4double GetStartTime() const overr
145 inline G4double GetEndTime() const overrid
146 inline G4double GetTimeStep() const overri
147 inline G4double GetPreviousTimeStep() cons
148 inline G4double GetGlobalTime() const over
149 inline void SetUserAction(G4UserTimeStepAc
150 inline G4UserTimeStepAction* GetUserTimeSt
151
152 // To use with transportation only, no rea
153 inline void UseDefaultTimeSteps(G4bool);
154 inline G4bool AreDefaultTimeStepsUsed();
155
156 inline G4ITStepStatus GetStatus() const;
157
158 /* 1 : Reaction information
159 * 2 : (1) + time step information
160 * 3 : (2) + step info for individual trac
161 * 4 : (2) + trackList processing info + p
162 */
163 inline void SetVerbose(G4int) override;
164
165 inline G4int GetVerbose() const;
166
167 inline void WhyDoYouStop();
168
169 void SetInteractivity(G4ITTrackingInteract
170 inline G4ITTrackingInteractivity* GetInter
171
172 virtual size_t GetNTracks();
173
174 void GetCollisionType(G4String& interactio
175
176 void AddWatchedTime(G4double time) { fWatc
177
178 G4double GetNextWatchedTime() const;
179
180 inline void SetMaxTimeStep(G4double maxTim
181
182 inline G4double GetMaxTimeStep() const { r
183
184 inline G4VScavengerMaterial* GetScavengerM
185 inline void SetScavengerMaterial(std::uniq
186 {
187 fpUserScavenger = std::move(scavengerMat
188 }
189
190 protected:
191 void DoProcess();
192 void SynchronizeTracks();
193 void Stepping();
194
195 void FindUserPreDefinedTimeStep();
196
197 G4bool CanICarryOn();
198
199 void PrintWhyDoYouStop();
200
201 private:
202 G4Scheduler();
203 void Create();
204
205 G4SchedulerMessenger* fpMessenger = nullpt
206
207 static G4ThreadLocal G4Scheduler* fgSchedu
208 G4int fVerbose;
209 G4bool fWhyDoYouStop;
210 G4bool fInitialized;
211 G4bool fRunning;
212 G4bool fContinue;
213
214 G4int fNbSteps;
215 G4int fMaxSteps;
216
217 G4ITStepStatus fITStepStatus;
218
219 // Time members
220 G4bool fUseDefaultTimeSteps;
221 G4double fTimeTolerance;
222 G4double fGlobalTime;
223 G4double fStartTime;
224 G4double fStopTime;
225 G4double fEndTime;
226 G4double fPreviousTimeStep;
227 G4int fZeroTimeCount;
228 G4int fMaxNZeroTimeStepsAllowed;
229
230 G4double fTimeStep; // The selected minim
231 G4double fMaxTimeStep;
232
233 // User steps
234 G4bool fUsePreDefinedTimeSteps;
235 G4double fDefaultMinTimeStep;
236 std::map<G4double, G4double>* fpUserTimeSt
237 // One can give time steps in respect to t
238 mutable G4double fUserUpperTimeLimit;
239 G4double fDefinedMinTimeStep;
240 // selected user time step in respect to t
241 G4bool fReachedUserTimeLimit; // if fMinT
242
243 std::set<G4double> fWatchedTimes;
244
245 G4UserTimeStepAction* fpUserTimeStepAction
246
247 std::unique_ptr<G4VScavengerMaterial> fpUs
248
249 // =======================================
250 // TO BE REMOVED
251 G4ITStepProcessor* fpStepProcessor = nullp
252 G4ITModelProcessor* fpModelProcessor = nul
253 G4ITTrackingManager* fpTrackingManager = n
254 G4ITTrackingInteractivity* fpTrackingInter
255 G4ITReactionSet* fReactionSet = nullptr;
256 G4ITTrackHolder& fTrackContainer;
257 G4ITModelHandler* fpModelHandler = nullptr
258 // =======================================
259
260 G4double fTSTimeStep;
261 // Time calculated by the time stepper in
262 G4double fILTimeStep;
263 // Time calculated by the interaction leng
264 // in ComputeInteractionLength()
265
266 G4bool fInteractionStep;
267 // Flag : if the step is driven by the int
268 // NOT by the reaction between tracks
269
270 G4ITGun* fpGun;
271
272 // =======================================
273 // Hoang
274 G4bool fResetScavenger;
275
276 public:
277 void ResetScavenger(bool);
278 };
279
280 inline G4bool G4Scheduler::IsInitialized()
281 {
282 return fInitialized;
283 }
284
285 inline G4ITModelHandler* G4Scheduler::GetModel
286 {
287 return fpModelHandler;
288 }
289
290 inline void G4Scheduler::SetEndTime(const G4do
291 {
292 fEndTime = __endtime;
293 }
294
295 inline void G4Scheduler::SetTimeSteps(std::map
296 {
297 fUsePreDefinedTimeSteps = true;
298 fpUserTimeSteps = steps;
299 }
300
301 inline void G4Scheduler::AddTimeStep(G4double
302 {
303 if (fpUserTimeSteps == nullptr) {
304 fpUserTimeSteps = new std::map<G4double, G
305 fUsePreDefinedTimeSteps = true;
306 }
307
308 (*fpUserTimeSteps)[startingTime] = timeStep;
309 }
310
311 inline G4int G4Scheduler::GetNbSteps() const
312 {
313 return fNbSteps;
314 }
315
316 inline void G4Scheduler::SetMaxNbSteps(G4int m
317 {
318 fMaxSteps = maxSteps;
319 }
320
321 inline G4int G4Scheduler::GetMaxNbSteps() cons
322 {
323 return fMaxSteps;
324 }
325
326 inline G4double G4Scheduler::GetStartTime() co
327 {
328 return fStartTime;
329 }
330
331 inline G4double G4Scheduler::GetEndTime() cons
332 {
333 return fEndTime;
334 }
335
336 inline G4double G4Scheduler::GetTimeStep() con
337 {
338 return fTimeStep;
339 }
340
341 inline void G4Scheduler::SetDefaultTimeStep(G4
342 {
343 fDefaultMinTimeStep = timeStep;
344 }
345
346 inline G4double G4Scheduler::GetGlobalTime() c
347 {
348 return fGlobalTime;
349 }
350
351 inline void G4Scheduler::SetUserAction(G4UserT
352 {
353 fpUserTimeStepAction = userITAction;
354 }
355
356 inline G4UserTimeStepAction* G4Scheduler::GetU
357 {
358 return fpUserTimeStepAction;
359 }
360
361 inline void G4Scheduler::SetVerbose(G4int verb
362 {
363 fVerbose = verbose;
364 }
365
366 inline G4int G4Scheduler::GetVerbose() const
367 {
368 return fVerbose;
369 }
370
371 inline void G4Scheduler::SetMaxZeroTimeAllowed
372 {
373 fMaxNZeroTimeStepsAllowed = maxTimeStepAllow
374 }
375
376 inline G4int G4Scheduler::GetMaxZeroTimeAllowe
377 {
378 return fMaxNZeroTimeStepsAllowed;
379 }
380
381 inline void G4Scheduler::SetTimeTolerance(G4do
382 {
383 fTimeTolerance = time;
384 }
385
386 inline G4double G4Scheduler::GetTimeTolerance(
387 {
388 return fTimeTolerance;
389 }
390
391 inline G4double G4Scheduler::GetPreviousTimeSt
392 {
393 return fPreviousTimeStep;
394 }
395
396 inline G4ITStepStatus G4Scheduler::GetStatus()
397 {
398 return fITStepStatus;
399 }
400
401 inline void G4Scheduler::Stop()
402 {
403 fContinue = false;
404 }
405
406 inline G4ITTrackingInteractivity* G4Scheduler:
407 {
408 return fpTrackingInteractivity;
409 }
410
411 inline void G4Scheduler::SetGun(G4ITGun* gun)
412 {
413 fpGun = gun;
414 }
415
416 inline G4ITGun* G4Scheduler::GetGun()
417 {
418 return fpGun;
419 }
420
421 inline void G4Scheduler::WhyDoYouStop()
422 {
423 fWhyDoYouStop = true;
424 }
425
426 inline void G4Scheduler::UseDefaultTimeSteps(G
427 {
428 fUseDefaultTimeSteps = flag;
429 }
430
431 inline G4bool G4Scheduler::AreDefaultTimeSteps
432 {
433 return (!fUseDefaultTimeSteps && !fUsePreDef
434 }
435
436 inline void G4Scheduler::ResetScavenger(bool v
437 {
438 fResetScavenger = value;
439 }
440
441 #endif
442