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