Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/management/include/G4Scheduler.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  1 //
  2 // ********************************************************************
  3 // * License and Disclaimer                                           *
  4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.                             *
 10 // *                                                                  *
 11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                                                  *
 18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // ********************************************************************
 25 //
 26 //
 27 // Author: Mathieu Karamitros
 28 
 29 // The code is developed in the framework of the ESA AO7146
 30 //
 31 // We would be very happy hearing from you, send us your feedback! :)
 32 //
 33 // In order for Geant4-DNA to be maintained and still open-source,
 34 // article citations are crucial.
 35 // If you use Geant4-DNA chemistry and you publish papers about your software,
 36 // in addition to the general paper on Geant4-DNA:
 37 //
 38 // Int. J. Model. Simul. Sci. Comput. 1 (2010) 157–178
 39 //
 40 // we would be very happy if you could please also cite the following
 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* lhs) const
 77     {
 78       return rhs->GetTrackID() < lhs->GetTrackID();
 79     }
 80 };
 81 #endif
 82 
 83 /**
 84  * G4Scheduler synchronizes (in time) track stepping
 85  */
 86 class G4Scheduler : public G4VScheduler, public G4VStateDependent
 87 {
 88   protected:
 89     ~G4Scheduler() override;
 90 
 91   public:
 92     G4Scheduler(const G4Scheduler&) = delete;
 93     G4Scheduler& operator=(const G4Scheduler&) = delete;
 94 
 95     static G4Scheduler* Instance();
 96     /** DeleteInstance should be used instead
 97      * of the destructor
 98      */
 99     static void DeleteInstance();
100     G4bool Notify(G4ApplicationState requestedState) override;
101 
102     void RegisterModel(G4VITStepModel*, G4double) override;
103 
104     void Initialize() override;
105     void ForceReinitialization();
106     inline G4bool IsInitialized();
107     inline G4bool IsRunning() override { return fRunning; }
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::EndProcessing()
119     // after fRunning flag has been turned off.
120     // This is not done automatically before UserReactionAction::EndProcessing()
121     // is called in case one would like to access some track information
122     void EndTracking();
123 
124     void SetEndTime(const G4double) override;
125 
126     /* Two tracks below the time tolerance are supposed to be
127      * in the same time slice
128      */
129     inline void SetTimeTolerance(G4double) override;
130     inline G4double GetTimeTolerance() const override;
131 
132     inline void SetMaxZeroTimeAllowed(G4int) override;
133     inline G4int GetMaxZeroTimeAllowed() const override;
134 
135     inline G4ITModelHandler* GetModelHandler() override;
136 
137     inline void SetTimeSteps(std::map<G4double, G4double>*) override;
138     inline void AddTimeStep(G4double, G4double) override;
139     inline void SetDefaultTimeStep(G4double) override;
140     G4double GetLimitingTimeStep() const override;
141     inline G4int GetNbSteps() const override;
142     inline void SetMaxNbSteps(G4int) override;
143     inline G4int GetMaxNbSteps() const override;
144     inline G4double GetStartTime() const override;
145     inline G4double GetEndTime() const override;
146     inline G4double GetTimeStep() const override;
147     inline G4double GetPreviousTimeStep() const override;
148     inline G4double GetGlobalTime() const override;
149     inline void SetUserAction(G4UserTimeStepAction*) override;
150     inline G4UserTimeStepAction* GetUserTimeStepAction() const override;
151 
152     // To use with transportation only, no reactions
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 tracks
161      * 4 : (2) + trackList processing info + pushed and killed track info
162      */
163     inline void SetVerbose(G4int) override;
164 
165     inline G4int GetVerbose() const;
166 
167     inline void WhyDoYouStop();
168 
169     void SetInteractivity(G4ITTrackingInteractivity*) override;
170     inline G4ITTrackingInteractivity* GetInteractivity() override;
171 
172     virtual size_t GetNTracks();
173 
174     void GetCollisionType(G4String& interactionType);
175 
176     void AddWatchedTime(G4double time) { fWatchedTimes.insert(time); }
177 
178     G4double GetNextWatchedTime() const;
179 
180     inline void SetMaxTimeStep(G4double maxTimeStep) { fMaxTimeStep = maxTimeStep; }
181 
182     inline G4double GetMaxTimeStep() const { return fMaxTimeStep; }
183 
184     inline G4VScavengerMaterial* GetScavengerMaterial() const { return fpUserScavenger.get(); }
185     inline void SetScavengerMaterial(std::unique_ptr<G4VScavengerMaterial> scavengerMaterial)
186     {
187       fpUserScavenger = std::move(scavengerMaterial);
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 = nullptr;
206 
207     static G4ThreadLocal G4Scheduler* fgScheduler;
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 minimum time step
231     G4double fMaxTimeStep;
232 
233     // User steps
234     G4bool fUsePreDefinedTimeSteps;
235     G4double fDefaultMinTimeStep;
236     std::map<G4double, G4double>* fpUserTimeSteps = nullptr;
237     // One can give time steps in respect to the global time
238     mutable G4double fUserUpperTimeLimit;
239     G4double fDefinedMinTimeStep;
240     // selected user time step in respect to the global time
241     G4bool fReachedUserTimeLimit;  // if fMinTimeStep == the user time step
242 
243     std::set<G4double> fWatchedTimes;
244 
245     G4UserTimeStepAction* fpUserTimeStepAction;
246 
247     std::unique_ptr<G4VScavengerMaterial> fpUserScavenger;
248 
249     // ==========================================
250     // TO BE REMOVED
251     G4ITStepProcessor* fpStepProcessor = nullptr;
252     G4ITModelProcessor* fpModelProcessor = nullptr;
253     G4ITTrackingManager* fpTrackingManager = nullptr;
254     G4ITTrackingInteractivity* fpTrackingInteractivity = nullptr;
255     G4ITReactionSet* fReactionSet = nullptr;
256     G4ITTrackHolder& fTrackContainer;
257     G4ITModelHandler* fpModelHandler = nullptr;
258     // ==========================================
259 
260     G4double fTSTimeStep;
261     // Time calculated by the time stepper in CalculateMinTimeStep()
262     G4double fILTimeStep;
263     // Time calculated by the interaction length methods
264     // in ComputeInteractionLength()
265 
266     G4bool fInteractionStep;
267     // Flag : if the step is driven by the interaction with the matter and
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::GetModelHandler()
286 {
287   return fpModelHandler;
288 }
289 
290 inline void G4Scheduler::SetEndTime(const G4double __endtime)
291 {
292   fEndTime = __endtime;
293 }
294 
295 inline void G4Scheduler::SetTimeSteps(std::map<G4double, G4double>* steps)
296 {
297   fUsePreDefinedTimeSteps = true;
298   fpUserTimeSteps = steps;
299 }
300 
301 inline void G4Scheduler::AddTimeStep(G4double startingTime, G4double timeStep)
302 {
303   if (fpUserTimeSteps == nullptr) {
304     fpUserTimeSteps = new std::map<G4double, G4double>();
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 maxSteps)
317 {
318   fMaxSteps = maxSteps;
319 }
320 
321 inline G4int G4Scheduler::GetMaxNbSteps() const
322 {
323   return fMaxSteps;
324 }
325 
326 inline G4double G4Scheduler::GetStartTime() const
327 {
328   return fStartTime;
329 }
330 
331 inline G4double G4Scheduler::GetEndTime() const
332 {
333   return fEndTime;
334 }
335 
336 inline G4double G4Scheduler::GetTimeStep() const
337 {
338   return fTimeStep;
339 }
340 
341 inline void G4Scheduler::SetDefaultTimeStep(G4double timeStep)
342 {
343   fDefaultMinTimeStep = timeStep;
344 }
345 
346 inline G4double G4Scheduler::GetGlobalTime() const
347 {
348   return fGlobalTime;
349 }
350 
351 inline void G4Scheduler::SetUserAction(G4UserTimeStepAction* userITAction)
352 {
353   fpUserTimeStepAction = userITAction;
354 }
355 
356 inline G4UserTimeStepAction* G4Scheduler::GetUserTimeStepAction() const
357 {
358   return fpUserTimeStepAction;
359 }
360 
361 inline void G4Scheduler::SetVerbose(G4int verbose)
362 {
363   fVerbose = verbose;
364 }
365 
366 inline G4int G4Scheduler::GetVerbose() const
367 {
368   return fVerbose;
369 }
370 
371 inline void G4Scheduler::SetMaxZeroTimeAllowed(G4int maxTimeStepAllowed)
372 {
373   fMaxNZeroTimeStepsAllowed = maxTimeStepAllowed;
374 }
375 
376 inline G4int G4Scheduler::GetMaxZeroTimeAllowed() const
377 {
378   return fMaxNZeroTimeStepsAllowed;
379 }
380 
381 inline void G4Scheduler::SetTimeTolerance(G4double time)
382 {
383   fTimeTolerance = time;
384 }
385 
386 inline G4double G4Scheduler::GetTimeTolerance() const
387 {
388   return fTimeTolerance;
389 }
390 
391 inline G4double G4Scheduler::GetPreviousTimeStep() const
392 {
393   return fPreviousTimeStep;
394 }
395 
396 inline G4ITStepStatus G4Scheduler::GetStatus() const
397 {
398   return fITStepStatus;
399 }
400 
401 inline void G4Scheduler::Stop()
402 {
403   fContinue = false;
404 }
405 
406 inline G4ITTrackingInteractivity* G4Scheduler::GetInteractivity()
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(G4bool flag)
427 {
428   fUseDefaultTimeSteps = flag;
429 }
430 
431 inline G4bool G4Scheduler::AreDefaultTimeStepsUsed()
432 {
433   return (!fUseDefaultTimeSteps && !fUsePreDefinedTimeSteps);
434 }
435 
436 inline void G4Scheduler::ResetScavenger(bool value)
437 {
438   fResetScavenger = value;
439 }
440 
441 #endif
442