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