Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/management/include/G4VProcess.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 ]

Diff markup

Differences between /processes/management/include/G4VProcess.hh (Version 11.3.0) and /processes/management/include/G4VProcess.hh (Version 1.0)


                                                   >>   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-01-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