| 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 // G4VProcess 26 // G4VProcess
27 // 27 //
28 // Class description: 28 // Class description:
29 // 29 //
30 // This class is the virtual class for physics 30 // This class is the virtual class for physics process objects.
31 // It defines public methods which describe th 31 // It defines public methods which describe the behavior of
32 // a physics process. 32 // a physics process.
33 33
34 // Authors: 34 // Authors:
35 // - 2 December 1995, G.Cosmo - First implemen 35 // - 2 December 1995, G.Cosmo - First implementation, based on object model
36 // - 18 December 1996, H.Kurashige - New Physi 36 // - 18 December 1996, H.Kurashige - New Physics scheme
37 // ------------------------------------------- 37 // --------------------------------------------------------------------
38 #ifndef G4VProcess_hh 38 #ifndef G4VProcess_hh
39 #define G4VProcess_hh 1 39 #define G4VProcess_hh 1
40 40
41 #include <cmath> 41 #include <cmath>
42 42
43 #include "globals.hh" 43 #include "globals.hh"
44 #include "G4ios.hh" 44 #include "G4ios.hh"
45 #include "Randomize.hh" 45 #include "Randomize.hh"
46 46
47 #include "G4PhysicsTable.hh" 47 #include "G4PhysicsTable.hh"
48 #include "G4VParticleChange.hh" 48 #include "G4VParticleChange.hh"
49 #include "G4ForceCondition.hh" 49 #include "G4ForceCondition.hh"
50 #include "G4GPILSelection.hh" 50 #include "G4GPILSelection.hh"
51 #include "G4ParticleChange.hh" 51 #include "G4ParticleChange.hh"
52 #include "G4ProcessType.hh" 52 #include "G4ProcessType.hh"
53 53
54 class G4ParticleDefinition; 54 class G4ParticleDefinition;
55 class G4DynamicParticle; 55 class G4DynamicParticle;
56 class G4Track; 56 class G4Track;
57 class G4Step; 57 class G4Step;
58 class G4ProcessTable; 58 class G4ProcessTable;
59 59
60 class G4VProcess 60 class G4VProcess
61 { 61 {
62 62
63 public: 63 public:
64 64
65 G4VProcess(const G4String& aName = "NoName 65 G4VProcess(const G4String& aName = "NoName",
66 G4ProcessType aType = fNotDefin 66 G4ProcessType aType = fNotDefined);
67 // Constructor requires the process name 67 // Constructor requires the process name and type
68 68
69 G4VProcess(const G4VProcess& right); 69 G4VProcess(const G4VProcess& right);
70 // Copy constructor copies the name but 70 // Copy constructor copies the name but does not copy the
71 // physics table (null pointer is assign 71 // physics table (null pointer is assigned instead)
72 72
73 virtual ~G4VProcess(); 73 virtual ~G4VProcess();
74 // Destructor 74 // Destructor
75 75
76 G4VProcess& operator=(const G4VProcess&) = 76 G4VProcess& operator=(const G4VProcess&) = delete;
77 77
78 G4bool operator==(const G4VProcess& right) 78 G4bool operator==(const G4VProcess& right) const;
79 G4bool operator!=(const G4VProcess& right) 79 G4bool operator!=(const G4VProcess& right) const;
80 // Equality operators 80 // Equality operators
81 81
82 //////////////////////////// 82 ////////////////////////////
83 // DoIt ///////////////// 83 // DoIt /////////////////
84 //////////////////////////// 84 ////////////////////////////
85 85
86 virtual G4VParticleChange* PostStepDoIt( 86 virtual G4VParticleChange* PostStepDoIt(
87 const G4Track& tr 87 const G4Track& track,
88 const G4Step& ste 88 const G4Step& stepData
89 ) = 0; 89 ) = 0;
90 90
91 virtual G4VParticleChange* AlongStepDoIt( 91 virtual G4VParticleChange* AlongStepDoIt(
92 const G4Track& tr 92 const G4Track& track,
93 const G4Step& ste 93 const G4Step& stepData
94 ) = 0; 94 ) = 0;
95 virtual G4VParticleChange* AtRestDoIt( 95 virtual G4VParticleChange* AtRestDoIt(
96 const G4Track& tr 96 const G4Track& track,
97 const G4Step& ste 97 const G4Step& stepData
98 ) = 0; 98 ) = 0;
99 // A virtual base class function that ha 99 // A virtual base class function that has to be overridden
100 // by any subclass. The DoIt() method ac 100 // by any subclass. The DoIt() method actually performs the
101 // physics process and determines either 101 // physics process and determines either momentum change
102 // of the production of secondaries etc. 102 // of the production of secondaries etc.
103 // Arguments 103 // Arguments
104 // const G4Track& track: 104 // const G4Track& track:
105 // reference to the current G4Tra 105 // reference to the current G4Track information
106 // const G4Step& stepData: 106 // const G4Step& stepData:
107 // reference to the current G4Ste 107 // reference to the current G4Step information
108 108
109 ////////////////////////// 109 //////////////////////////
110 // GPIL /////////////// 110 // GPIL ///////////////
111 ////////////////////////// 111 //////////////////////////
112 112
113 virtual G4double AlongStepGetPhysicalInter 113 virtual G4double AlongStepGetPhysicalInteractionLength(
114 const G4Track& tr 114 const G4Track& track,
115 G4double previous 115 G4double previousStepSize,
116 G4double currentM 116 G4double currentMinimumStep,
117 G4double& propose 117 G4double& proposedSafety,
118 G4GPILSelection* 118 G4GPILSelection* selection) = 0;
119 119
120 virtual G4double AtRestGetPhysicalInteract 120 virtual G4double AtRestGetPhysicalInteractionLength(
121 const G4Track& tr 121 const G4Track& track,
122 G4ForceCondition* 122 G4ForceCondition* condition ) = 0;
123 123
124 virtual G4double PostStepGetPhysicalIntera 124 virtual G4double PostStepGetPhysicalInteractionLength(
125 const G4Track& tr 125 const G4Track& track,
126 G4double previous 126 G4double previousStepSize,
127 G4ForceCondition* 127 G4ForceCondition* condition ) = 0;
128 // Returns the Step-size (actual length 128 // Returns the Step-size (actual length) which is allowed
129 // by "this" process. (for AtRestGetPhy 129 // by "this" process. (for AtRestGetPhysicalInteractionLength,
130 // return value is Step-time) The Numbe 130 // return value is Step-time) The NumberOfInteractionLengthLeft is
131 // recalculated by using previousStepSi 131 // recalculated by using previousStepSize and the Step-size is
132 // calucalted accoding to the resultant 132 // calucalted accoding to the resultant NumberOfInteractionLengthLeft.
133 // using NumberOfInteractionLengthLeft, 133 // using NumberOfInteractionLengthLeft, which is recalculated at
134 // arguments 134 // arguments
135 // const G4Track& track: 135 // const G4Track& track:
136 // reference to the current G4Tra 136 // reference to the current G4Track information
137 // G4double* previousStepS 137 // G4double* previousStepSize:
138 // the Step-size (actual length) 138 // the Step-size (actual length) of the previous Step
139 // of this track. Negative calue 139 // of this track. Negative calue indicates that
140 // NumberOfInteractionLengthLeft 140 // NumberOfInteractionLengthLeft must be reset.
141 // the current physical interacti 141 // the current physical interaction legth of this process
142 // G4ForceCondition* condition: 142 // G4ForceCondition* condition:
143 // the flag indicates DoIt of thi 143 // the flag indicates DoIt of this process is forced
144 // to be called 144 // to be called
145 // Forced: Corresponding DoIt 145 // Forced: Corresponding DoIt is forced
146 // NotForced: Corresponding DoIt 146 // NotForced: Corresponding DoIt is called
147 // if the Step size o 147 // if the Step size of this Step is determined
148 // by this process 148 // by this process
149 // !! AlongStepDoIt is always cal 149 // !! AlongStepDoIt is always called !!
150 // G4double& currentMinimumStep: 150 // G4double& currentMinimumStep:
151 // this value is used for transfo 151 // this value is used for transformation of
152 // true path length to geometrica 152 // true path length to geometrical path length
153 153
154 inline G4double GetCurrentInteractionLengt 154 inline G4double GetCurrentInteractionLength() const;
155 // Returns currentInteractionLength 155 // Returns currentInteractionLength
156 156
157 ////////// PIL factor //////// 157 ////////// PIL factor ////////
158 // 158 //
159 inline void SetPILfactor(G4double value); 159 inline void SetPILfactor(G4double value);
160 inline G4double GetPILfactor() const; 160 inline G4double GetPILfactor() const;
161 // Set/Get factor for PhysicsInteraction 161 // Set/Get factor for PhysicsInteractionLength
162 // which is passed to G4SteppingManager 162 // which is passed to G4SteppingManager for both AtRest and PostStep
163 163
164 // These three GPIL methods are used by St 164 // These three GPIL methods are used by Stepping Manager.
165 // They invoke virtual GPIL methods listed 165 // They invoke virtual GPIL methods listed above.
166 // As for AtRest and PostStep the returned 166 // As for AtRest and PostStep the returned value is multipled by
167 // thePILfactor 167 // thePILfactor
168 // 168 //
169 inline G4double AlongStepGPIL( const G4Tra 169 inline G4double AlongStepGPIL( const G4Track& track,
170 G4double pr 170 G4double previousStepSize,
171 G4double cu 171 G4double currentMinimumStep,
172 G4double& p 172 G4double& proposedSafety,
173 G4GPILSelec 173 G4GPILSelection* selection );
174 174
175 inline G4double AtRestGPIL( const G4Track& 175 inline G4double AtRestGPIL( const G4Track& track,
176 G4ForceConditi 176 G4ForceCondition* condition );
177 177
178 inline G4double PostStepGPIL( const G4Trac 178 inline G4double PostStepGPIL( const G4Track& track,
179 G4double pre 179 G4double previousStepSize,
180 G4ForceCondi 180 G4ForceCondition* condition );
181 181
182 virtual G4bool IsApplicable(const G4Partic 182 virtual G4bool IsApplicable(const G4ParticleDefinition&) { return true; }
183 // Returns true if this process object i 183 // Returns true if this process object is applicable to
184 // the particle type. Process will not b 184 // the particle type. Process will not be registered to a
185 // particle if IsApplicable is false 185 // particle if IsApplicable is false
186 186
187 virtual void BuildPhysicsTable(const G4Par 187 virtual void BuildPhysicsTable(const G4ParticleDefinition&) {}
188 // Messaged by the Particle definition ( 188 // Messaged by the Particle definition (via the Process manager)
189 // whenever cross-section tables have to 189 // whenever cross-section tables have to be rebuilt (i.e. if new
190 // materials have been defined). 190 // materials have been defined).
191 // It is overloaded by individual proces 191 // It is overloaded by individual processes when they need physics
192 // tables 192 // tables
193 193
194 virtual void PreparePhysicsTable(const G4P 194 virtual void PreparePhysicsTable(const G4ParticleDefinition&) {}
195 // Messaged by the Particle definition ( 195 // Messaged by the Particle definition (via the Process manager)
196 // whenever cross-section tables have to 196 // whenever cross-section tables have to be prepared for rebuild
197 // (i.e. if new materials have been defi 197 // (i.e. if new materials have been defined).
198 // It is overloaded by individual proces 198 // It is overloaded by individual processes when they need physics
199 // tables 199 // tables
200 200
201 // Processes which Build physics tables in 201 // Processes which Build physics tables independent of cuts
202 // (for example in their constructors) sho 202 // (for example in their constructors) should preferably use private
203 // void BuildThePhysicsTable() and void Pr 203 // void BuildThePhysicsTable() and void PreparePhysicsTable().
204 // *Not* another BuildPhysicsTable 204 // *Not* another BuildPhysicsTable
205 205
206 virtual G4bool StorePhysicsTable(const G4P 206 virtual G4bool StorePhysicsTable(const G4ParticleDefinition* ,
207 const G4S 207 const G4String&, G4bool) { return true; }
208 // Store PhysicsTable in a file. 208 // Store PhysicsTable in a file.
209 // Return false in case of failure at I/ 209 // Return false in case of failure at I/O
210 210
211 virtual G4bool RetrievePhysicsTable(const 211 virtual G4bool RetrievePhysicsTable(const G4ParticleDefinition* ,
212 const G4 212 const G4String&, G4bool) { return false; }
213 // Retrieve Physics from a file. 213 // Retrieve Physics from a file.
214 // Return true if the Physics Table can 214 // Return true if the Physics Table can be built by using file.
215 // Return false if the process has no fu 215 // Return false if the process has no functionality or in case
216 // of failure. File name should be defin 216 // of failure. File name should be defined by each process and the
217 // file should be placed under the direc 217 // file should be placed under the directory specified by the argument
218 218
219 const G4String& GetPhysicsTableFileName(co 219 const G4String& GetPhysicsTableFileName(const G4ParticleDefinition* ,
220 co 220 const G4String& directory,
221 co 221 const G4String& tableName,
222 G4 222 G4bool ascii = false);
223 // This method is utility for Store/Retr 223 // This method is utility for Store/RetreivePhysicsTable
224 224
225 inline const G4String& GetProcessName() co 225 inline const G4String& GetProcessName() const;
226 // Returns the name of the process 226 // Returns the name of the process
227 227
228 inline G4ProcessType GetProcessType() cons 228 inline G4ProcessType GetProcessType() const;
229 // Returns the process type 229 // Returns the process type
230 230
231 inline void SetProcessType(G4ProcessType); 231 inline void SetProcessType(G4ProcessType);
232 // Sets the process type 232 // Sets the process type
233 233
234 inline G4int GetProcessSubType() const; 234 inline G4int GetProcessSubType() const;
235 // Returns the process sub type 235 // Returns the process sub type
236 236
237 inline void SetProcessSubType(G4int); 237 inline void SetProcessSubType(G4int);
238 // Sets the process sub type 238 // Sets the process sub type
239 239
240 static const G4String& GetProcessTypeName( 240 static const G4String& GetProcessTypeName(G4ProcessType);
241 // Returns the process type name 241 // Returns the process type name
242 242
243 virtual const G4VProcess* GetCreatorProces <<
244 // Returns the process to be used as Cre <<
245 // coming from this process <<
246 <<
247 virtual void StartTracking(G4Track*); 243 virtual void StartTracking(G4Track*);
248 virtual void EndTracking(); 244 virtual void EndTracking();
249 // Inform Start/End of tracking for each 245 // Inform Start/End of tracking for each track to the physics process
250 246
251 virtual void SetProcessManager(const G4Pro 247 virtual void SetProcessManager(const G4ProcessManager*);
252 // A process manager sets its own pointe 248 // A process manager sets its own pointer when the process
253 // is registered in the process Manager 249 // is registered in the process Manager
254 virtual const G4ProcessManager* GetProcess 250 virtual const G4ProcessManager* GetProcessManager();
255 // Get the process manager which the pro 251 // Get the process manager which the process belongs to
256 252
257 virtual void ResetNumberOfInteractionLengt 253 virtual void ResetNumberOfInteractionLengthLeft();
258 // Reset (determine the value of) Number 254 // Reset (determine the value of) NumberOfInteractionLengthLeft
259 255
260 inline G4double GetNumberOfInteractionLeng 256 inline G4double GetNumberOfInteractionLengthLeft() const;
261 // Get NumberOfInteractionLengthLeft 257 // Get NumberOfInteractionLengthLeft
262 258
263 inline G4double GetTotalNumberOfInteractio 259 inline G4double GetTotalNumberOfInteractionLengthTraversed() const;
264 // Get NumberOfInteractionLength after 260 // Get NumberOfInteractionLength after
265 // ResetNumberOfInteractionLengthLeft() 261 // ResetNumberOfInteractionLengthLeft() is invoked
266 262
267 inline G4bool isAtRestDoItIsEnabled() cons 263 inline G4bool isAtRestDoItIsEnabled() const;
268 inline G4bool isAlongStepDoItIsEnabled() c 264 inline G4bool isAlongStepDoItIsEnabled() const;
269 inline G4bool isPostStepDoItIsEnabled() co 265 inline G4bool isPostStepDoItIsEnabled() const;
270 // These methods indicate which DoIt is 266 // These methods indicate which DoIt is enabled.
271 // They are used by G4ProcessManager to 267 // They are used by G4ProcessManager to check
272 // that ordering parameters are properly 268 // that ordering parameters are properly set
273 269
274 virtual void DumpInfo() const; 270 virtual void DumpInfo() const;
275 // Dump out process information 271 // Dump out process information
276 272
277 virtual void ProcessDescription(std::ostre 273 virtual void ProcessDescription(std::ostream& outfile) const;
278 // Write out to html file for automatic 274 // Write out to html file for automatic documentation
279 275
280 inline void SetVerboseLevel(G4int value); 276 inline void SetVerboseLevel(G4int value);
281 inline G4int GetVerboseLevel() const; 277 inline G4int GetVerboseLevel() const;
282 // set/get control flag for output messa 278 // set/get control flag for output message
283 // 0: Silent 279 // 0: Silent
284 // 1: Warning message 280 // 1: Warning message
285 // 2: More 281 // 2: More
286 282
287 virtual void SetMasterProcess(G4VProcess* 283 virtual void SetMasterProcess(G4VProcess* masterP);
288 // Sets the master thread process instan 284 // Sets the master thread process instance
289 inline const G4VProcess* GetMasterProcess( 285 inline const G4VProcess* GetMasterProcess() const;
290 // Returns the master thread process ins 286 // Returns the master thread process instance.
291 // Can be used to initialise worker type 287 // Can be used to initialise worker type processes
292 // instances from master one (e.g. to sh 288 // instances from master one (e.g. to share a read-only table)
293 // if ( this != GetMasterProcess() ) { / 289 // if ( this != GetMasterProcess() ) { /*worker*/ }
294 // else { /* master or sequential */ } 290 // else { /* master or sequential */ }
295 291
296 virtual void BuildWorkerPhysicsTable(const 292 virtual void BuildWorkerPhysicsTable(const G4ParticleDefinition& part);
297 // Messaged by the Particle definition ( 293 // Messaged by the Particle definition (via the Process manager)
298 // in worker threads. See BuildWorkerPhy 294 // in worker threads. See BuildWorkerPhyiscsTable() method.
299 // Can be used to share among threads ph 295 // Can be used to share among threads physics tables.
300 // Use GetMasterProcess() to get pointer 296 // Use GetMasterProcess() to get pointer of master process from
301 // worker thread. 297 // worker thread.
302 // By default this method makes a forwar 298 // By default this method makes a forward call to BuildPhysicsTable()
303 299
304 virtual void PrepareWorkerPhysicsTable(con 300 virtual void PrepareWorkerPhysicsTable(const G4ParticleDefinition&);
305 // Messaged by the Particle definition ( 301 // Messaged by the Particle definition (via the Process manager)
306 // in worker threads. See Preparephysics 302 // in worker threads. See PreparephysicsTable().
307 // Can be used to share among threads ph 303 // Can be used to share among threads physics tables.
308 // Use GetMasterProcess() to get pointer 304 // Use GetMasterProcess() to get pointer of master process from
309 // worker thread 305 // worker thread
310 // By default this method makes a forwar 306 // By default this method makes a forward call to PreparePhysicsTable()
311 307
312 protected: 308 protected:
313 309
314 inline void SubtractNumberOfInteractionLen 310 inline void SubtractNumberOfInteractionLengthLeft(G4double prevStepSize);
315 // Subtract NumberOfInteractionLengthLef 311 // Subtract NumberOfInteractionLengthLeft by the value corresponding
316 // to previousStepSize 312 // to previousStepSize
317 313
318 inline void ClearNumberOfInteractionLength 314 inline void ClearNumberOfInteractionLengthLeft();
319 // This method should be at the end of P 315 // This method should be at the end of PostStepDoIt() and AtRestDoIt()!
320 316
321 protected: 317 protected:
322 318
323 const G4ProcessManager* aProcessManager = 319 const G4ProcessManager* aProcessManager = nullptr;
324 320
325 G4VParticleChange* pParticleChange = nullp 321 G4VParticleChange* pParticleChange = nullptr;
326 // The pointer to G4VParticleChange obje 322 // The pointer to G4VParticleChange object
327 // which is modified and returned by add 323 // which is modified and returned by address by the DoIt() method.
328 // This pointer should be set in each ph 324 // This pointer should be set in each physics process
329 // after construction of derived class o 325 // after construction of derived class object
330 326
331 G4ParticleChange aParticleChange; 327 G4ParticleChange aParticleChange;
332 // This object is kept for compatibility 328 // This object is kept for compatibility with old scheme.
333 // May be removed in future 329 // May be removed in future
334 330
335 G4double theNumberOfInteractionLengthLeft 331 G4double theNumberOfInteractionLengthLeft = -1.0;
336 // The flight length left for the curren 332 // The flight length left for the current tracking particle
337 // in unit of "Interaction length" 333 // in unit of "Interaction length"
338 334
339 G4double currentInteractionLength = -1.0; 335 G4double currentInteractionLength = -1.0;
340 // The InteractionLength in the current 336 // The InteractionLength in the current material
341 337
342 G4double theInitialNumberOfInteractionLeng 338 G4double theInitialNumberOfInteractionLength = -1.0;
343 // The initial value when ResetNumberOfI 339 // The initial value when ResetNumberOfInteractionLengthLeft() is invoked
344 340
345 G4String theProcessName; 341 G4String theProcessName;
346 // The name of the process 342 // The name of the process
347 343
348 G4String thePhysicsTableFileName; 344 G4String thePhysicsTableFileName;
349 345
350 G4ProcessType theProcessType = fNotDefined 346 G4ProcessType theProcessType = fNotDefined;
351 // The type of the process 347 // The type of the process
352 348
353 G4int theProcessSubType = -1; 349 G4int theProcessSubType = -1;
354 // The sub type of the process 350 // The sub type of the process
355 351
356 G4double thePILfactor = 1.0; 352 G4double thePILfactor = 1.0;
357 // Factor for PhysicsInteractionLength 353 // Factor for PhysicsInteractionLength
358 // which is passed to G4SteppingManager 354 // which is passed to G4SteppingManager
359 355
360 G4int verboseLevel = 0; 356 G4int verboseLevel = 0;
361 // Controle flag for output message 357 // Controle flag for output message
362 358
363 G4bool enableAtRestDoIt = true; 359 G4bool enableAtRestDoIt = true;
364 G4bool enableAlongStepDoIt = true; 360 G4bool enableAlongStepDoIt = true;
365 G4bool enablePostStepDoIt = true; 361 G4bool enablePostStepDoIt = true;
366 362
367 private: 363 private:
368 364
369 G4VProcess(); 365 G4VProcess();
370 // Hidden default constructor 366 // Hidden default constructor
371 367
372 private: 368 private:
373 369
374 G4VProcess* masterProcessShadow = nullptr; 370 G4VProcess* masterProcessShadow = nullptr;
375 // For multi-threaded: pointer to the in 371 // For multi-threaded: pointer to the instance of this process
376 // for the master thread 372 // for the master thread
377 373
378 G4ProcessTable* fProcessTable = nullptr; 374 G4ProcessTable* fProcessTable = nullptr;
379 }; 375 };
380 376
381 // ----------------------------------------- 377 // -----------------------------------------
382 // inlined function members implementation 378 // inlined function members implementation
383 // ----------------------------------------- 379 // -----------------------------------------
384 380
385 inline 381 inline
386 const G4String& G4VProcess::GetProcessName() c 382 const G4String& G4VProcess::GetProcessName() const
387 { 383 {
388 return theProcessName; 384 return theProcessName;
389 } 385 }
390 386
391 inline 387 inline
392 G4ProcessType G4VProcess::GetProcessType() con 388 G4ProcessType G4VProcess::GetProcessType() const
393 { 389 {
394 return theProcessType; 390 return theProcessType;
395 } 391 }
396 392
397 inline 393 inline
398 void G4VProcess::SetProcessType(G4ProcessType 394 void G4VProcess::SetProcessType(G4ProcessType aType)
399 { 395 {
400 theProcessType = aType; 396 theProcessType = aType;
401 } 397 }
402 398
403 inline 399 inline
404 G4int G4VProcess::GetProcessSubType() const 400 G4int G4VProcess::GetProcessSubType() const
405 { 401 {
406 return theProcessSubType; 402 return theProcessSubType;
407 } 403 }
408 404
409 inline 405 inline
410 void G4VProcess::SetProcessSubType(G4int value 406 void G4VProcess::SetProcessSubType(G4int value)
411 { 407 {
412 theProcessSubType = value; 408 theProcessSubType = value;
413 } 409 }
414 410
415 inline 411 inline
416 void G4VProcess::SetVerboseLevel(G4int value) 412 void G4VProcess::SetVerboseLevel(G4int value)
417 { 413 {
418 verboseLevel = value; 414 verboseLevel = value;
419 } 415 }
420 416
421 inline 417 inline
422 G4int G4VProcess::GetVerboseLevel() const 418 G4int G4VProcess::GetVerboseLevel() const
423 { 419 {
424 return verboseLevel; 420 return verboseLevel;
425 } 421 }
426 422
427 inline 423 inline
428 void G4VProcess::ClearNumberOfInteractionLengt 424 void G4VProcess::ClearNumberOfInteractionLengthLeft()
429 { 425 {
430 theInitialNumberOfInteractionLength = -1.0; 426 theInitialNumberOfInteractionLength = -1.0;
431 theNumberOfInteractionLengthLeft = -1.0; 427 theNumberOfInteractionLengthLeft = -1.0;
432 } 428 }
433 429
434 inline 430 inline
435 G4double G4VProcess::GetNumberOfInteractionLen 431 G4double G4VProcess::GetNumberOfInteractionLengthLeft() const
436 { 432 {
437 return theNumberOfInteractionLengthLeft; 433 return theNumberOfInteractionLengthLeft;
438 } 434 }
439 435
440 inline 436 inline
441 G4double G4VProcess::GetTotalNumberOfInteracti 437 G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed() const
442 { 438 {
443 return theInitialNumberOfInteractionLength - 439 return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
444 } 440 }
445 441
446 inline 442 inline
447 G4double G4VProcess::GetCurrentInteractionLeng 443 G4double G4VProcess::GetCurrentInteractionLength() const
448 { 444 {
449 return currentInteractionLength; 445 return currentInteractionLength;
450 } 446 }
451 447
452 inline 448 inline
453 void G4VProcess::SetPILfactor(G4double value) 449 void G4VProcess::SetPILfactor(G4double value)
454 { 450 {
455 if (value>0.) { thePILfactor = value; } 451 if (value>0.) { thePILfactor = value; }
456 } 452 }
457 453
458 inline 454 inline
459 G4double G4VProcess::GetPILfactor() const 455 G4double G4VProcess::GetPILfactor() const
460 { 456 {
461 return thePILfactor; 457 return thePILfactor;
462 } 458 }
463 459
464 inline 460 inline
465 G4double G4VProcess::AlongStepGPIL( const G4Tr 461 G4double G4VProcess::AlongStepGPIL( const G4Track& track,
466 G4double 462 G4double previousStepSize,
467 G4double 463 G4double currentMinimumStep,
468 G4double& 464 G4double& proposedSafety,
469 G4GPILSele 465 G4GPILSelection* selection )
470 { 466 {
471 return AlongStepGetPhysicalInteractionLength 467 return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
472 currentMinimumSte 468 currentMinimumStep, proposedSafety, selection);
473 } 469 }
474 470
475 inline 471 inline
476 G4double G4VProcess::AtRestGPIL( const G4Track 472 G4double G4VProcess::AtRestGPIL( const G4Track& track,
477 G4ForceCondit 473 G4ForceCondition* condition )
478 { 474 {
479 return thePILfactor * AtRestGetPhysicalInter 475 return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
480 } 476 }
481 477
482 inline 478 inline
483 G4double G4VProcess::PostStepGPIL( const G4Tra 479 G4double G4VProcess::PostStepGPIL( const G4Track& track,
484 G4double pr 480 G4double previousStepSize,
485 G4ForceCond 481 G4ForceCondition* condition )
486 { 482 {
487 return thePILfactor * 483 return thePILfactor *
488 PostStepGetPhysicalInteractionLength(tra 484 PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
489 } 485 }
490 486
491 inline 487 inline
492 void G4VProcess::SetProcessManager(const G4Pro 488 void G4VProcess::SetProcessManager(const G4ProcessManager* procMan)
493 { 489 {
494 aProcessManager = procMan; 490 aProcessManager = procMan;
495 } 491 }
496 492
497 inline 493 inline
498 const G4ProcessManager* G4VProcess::GetProcess 494 const G4ProcessManager* G4VProcess::GetProcessManager()
499 { 495 {
500 return aProcessManager; 496 return aProcessManager;
501 } 497 }
502 498
503 inline 499 inline
504 G4bool G4VProcess::isAtRestDoItIsEnabled() con 500 G4bool G4VProcess::isAtRestDoItIsEnabled() const
505 { 501 {
506 return enableAtRestDoIt; 502 return enableAtRestDoIt;
507 } 503 }
508 504
509 inline 505 inline
510 G4bool G4VProcess::isAlongStepDoItIsEnabled() 506 G4bool G4VProcess::isAlongStepDoItIsEnabled() const
511 { 507 {
512 return enableAlongStepDoIt; 508 return enableAlongStepDoIt;
513 } 509 }
514 510
515 inline 511 inline
516 G4bool G4VProcess::isPostStepDoItIsEnabled() c 512 G4bool G4VProcess::isPostStepDoItIsEnabled() const
517 { 513 {
518 return enablePostStepDoIt; 514 return enablePostStepDoIt;
519 } 515 }
520 516
521 inline 517 inline
522 const G4VProcess* G4VProcess::GetMasterProcess 518 const G4VProcess* G4VProcess::GetMasterProcess() const
523 { 519 {
524 return masterProcessShadow; 520 return masterProcessShadow;
525 } 521 }
526 522
527 inline 523 inline
528 void G4VProcess::SubtractNumberOfInteractionLe 524 void G4VProcess::SubtractNumberOfInteractionLengthLeft( G4double prevStepSize )
529 { 525 {
530 if (currentInteractionLength>0.0) 526 if (currentInteractionLength>0.0)
531 { 527 {
532 theNumberOfInteractionLengthLeft -= prevSt 528 theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
533 if(theNumberOfInteractionLengthLeft<0.) 529 if(theNumberOfInteractionLengthLeft<0.)
534 { 530 {
535 theNumberOfInteractionLengthLeft=CLHEP: 531 theNumberOfInteractionLengthLeft=CLHEP::perMillion;
536 } 532 }
537 } 533 }
538 else 534 else
539 { 535 {
540 #ifdef G4VERBOSE 536 #ifdef G4VERBOSE
541 if (verboseLevel>0) 537 if (verboseLevel>0)
542 { 538 {
543 G4cerr << "G4VProcess::SubtractNumberOfI 539 G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
544 G4cerr << " [" << theProcessName << "]" 540 G4cerr << " [" << theProcessName << "]" <<G4endl;
545 G4cerr << " currentInteractionLength = " 541 G4cerr << " currentInteractionLength = "
546 << currentInteractionLength << " 542 << currentInteractionLength << " [mm]";
547 G4cerr << " previousStepSize = " << prev 543 G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
548 G4cerr << G4endl; 544 G4cerr << G4endl;
549 } 545 }
550 #endif 546 #endif
551 G4String msg = "Negative currentInteractio 547 G4String msg = "Negative currentInteractionLength for ";
552 msg += theProcessName; 548 msg += theProcessName;
553 G4Exception("G4VProcess::SubtractNumberOfI 549 G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
554 "ProcMan201", EventMustBeAbort 550 "ProcMan201", EventMustBeAborted, msg);
555 } 551 }
556 } 552 }
557 553
558 #endif 554 #endif
559 555