Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/management/include/G4ProcessManager.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/G4ProcessManager.hh (Version 11.3.0) and /processes/management/include/G4ProcessManager.hh (Version 9.2.p4)


  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 // G4ProcessManager                            << 
 27 //                                                 26 //
 28 // Class Description:                          <<  27 // $Id: G4ProcessManager.hh,v 1.16 2007/10/02 08:23:20 kurasige Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-02-patch-04 $
 29 //                                                 29 //
 30 // G4ProcessManager collects all physics a par <<  30 // 
 31 // vectors. These vectors are:                 <<  31 // ------------------------------------------------------------
 32 // - one vector for all processes (called as " <<  32 //  GEANT 4 class header file 
 33 // - two vectors for processes with AtRestGetP <<  33 //
 34 //                              and AtRestDoIt <<  34 //  History: first implementation, based on object model of
 35 // - two vectors for processes with AlongStepG <<  35 //  2nd December 1995, G.Cosmo
 36 //                              and AlongStepD <<  36 //   ----------------  G4ProcessManager  -----------------
 37 // - two vectors for processes with PostStepGe <<  37 // Class Description 
 38 //                              and PostStepDo <<  38 //  It collects all physics a particle can undertake as seven vectors.
 39 // The tracking will message three types of Ge <<  39 //  These vectors are 
 40 // in order to limit the Step and select the o <<  40 //   one vector for all processes (called as "process List")
 41 // It will message the corresponding DoIt() to <<  41 //   two vectors for processes with AtRestGetPhysicalInteractionLength
 42 // processes. In addition, the Tracking will l <<  42 //                                    and AtRestDoIt
 43 // and select the occurrence of the processes  <<  43 //   two vectors for processes with AlongStepGetPhysicalInteractionLength
 44 // the shortest physical interaction length co <<  44 //                                    and AlongStepDoIt
 45 // processes at rest, for which the Tracking w <<  45 //   two vectors for processes with PostStepGetPhysicalInteractionLength
 46 // occurrence of the process which returns the <<  46 //                                    and PostStepDoIt
 47 // life-time from the GetPhysicalInteractionLe <<  47 //  The tracking will message three types of GetPhysicalInteractionLength
 48                                                <<  48 //  in order to limit the Step and select the occurence of processes. 
 49 // Authors:                                    <<  49 //  It will message the corresponding DoIt() to apply the selected 
 50 // - 02.12.1995, G.Cosmo - First implementatio <<  50 //  processes. In addition, the Tracking will limit the Step
 51 // - 06.05.1996, G.Cosmo - Revised; added vect <<  51 //  and select the occurence of the processes according to
 52 // - 08.01.1997, H.Kurashige - New Physics sch <<  52 //  the shortest physical interaction length computed (except for
 53 // ------------------------------------------- <<  53 //  processes at rest, for which the Tracking will select the
 54 #ifndef G4ProcessManager_hh                    <<  54 //  occurence of the process which returns the shortest mean
 55 #define G4ProcessManager_hh 1                  <<  55 //  life-time from the GetPhysicalInteractionLength()).
                                                   >>  56 //
                                                   >>  57 // History:
                                                   >>  58 // revised by G.Cosmo, 06 May 1996
                                                   >>  59 //    Added vector of processes at rest, 06 May 1996
                                                   >>  60 // ------------------------------------------------------------
                                                   >>  61 //   New Physics scheme           8 Jan. 1997  H.Kurahige
                                                   >>  62 //   Add SetProcessOrdering methods     27 Mar 1998  H.Kurahige
                                                   >>  63 //   Add copy constructor (deep copy)   28 June 1998 H.Kurashige
                                                   >>  64 //   Add GetProcessActivation     3 May. 1999 H.Kurashige
                                                   >>  65 //   Use STL vector instead of RW vector    1. Mar 00 H.Kurashige
                                                   >>  66 //   Modify G4ProcessVectorOrdering to fix FindInsedrtPosition 15 Feb. 2005
                                                   >>  67 //   Add  
                                                   >>  68 // ------------------------------------------------------------
 56                                                    69 
 57 #include <vector>                              <<  70 #ifndef G4ProcessManager_h
                                                   >>  71 #define G4ProcessManager_h 1
 58                                                    72 
 59 #include "globals.hh"                              73 #include "globals.hh"
 60 #include "G4ios.hh"                                74 #include "G4ios.hh"
                                                   >>  75 #include <vector>
 61                                                    76 
 62 #include "G4VProcess.hh"                           77 #include "G4VProcess.hh"
 63 #include "G4ProcessVector.hh"                      78 #include "G4ProcessVector.hh"
 64 #include "G4ParticleDefinition.hh"                 79 #include "G4ParticleDefinition.hh"
 65                                                    80 
 66 class G4ProcessManagerMessenger;                   81 class G4ProcessManagerMessenger;
 67 class G4ProcessAttribute;                          82 class G4ProcessAttribute;
 68                                                    83 
 69 // Indexes for ProcessVector                   <<  84 //  Indexes for ProcessVector
 70 //                                             << 
 71 enum G4ProcessVectorTypeIndex                      85 enum G4ProcessVectorTypeIndex
 72 {                                                  86 { 
 73   typeGPIL = 0,        // for GetPhysicalInter <<  87     typeGPIL = 0, // for GetPhysicalInteractionLength 
 74   typeDoIt =1          // for DoIt             <<  88   typeDoIt =1   // for DoIt
 75 };                                                 89 };
 76 enum G4ProcessVectorDoItIndex                      90 enum G4ProcessVectorDoItIndex
 77 {                                                  91 {
 78   idxAll = -1,         // for all DoIt/GPIL    <<  92     idxAll = -1,    // for all DoIt/GPIL 
 79   idxAtRest = 0,       // for AtRestDoIt/GPIL  <<  93     idxAtRest = 0,    // for AtRestDoIt/GPIL
 80   idxAlongStep = 1,    // for AlongStepDoIt/GP <<  94   idxAlongStep = 1,   // for AlongStepDoIt/GPIL
 81   idxPostStep =2,      // for AlongSTepDoIt/GP <<  95   idxPostStep =2    // for AlongSTepDoIt/GPIL
 82   NDoit =3                                     << 
 83 };                                                 96 };
 84                                                    97 
 85 // Enumeration for Ordering Parameter          <<  98 //  enumeration for Ordering Parameter      
 86 //                                             << 
 87 enum G4ProcessVectorOrdering                       99 enum G4ProcessVectorOrdering
 88 {                                                 100 { 
 89   ordInActive = -1,    // ordering parameter t << 101     ordInActive = -1,     // ordering parameter to indicate InActive DoIt
 90   ordDefault = 1000,   // default ordering par << 102     ordDefault = 1000,    // default ordering parameter
 91   ordLast    = 9999    // ordering parameter t << 103     ordLast    = 99999    // ordering parameter to indicate the last DoIt
 92 };                                                104 };
 93                                                   105 
 94 class G4ProcessManager                            106 class G4ProcessManager 
 95 {                                                 107 {
 96   using G4ProcessAttrVector = std::vector<G4Pr << 108  
 97                                                << 
 98   public:                                         109   public: 
                                                   >> 110       // copy constructor
                                                   >> 111       G4ProcessManager(G4ProcessManager &right);
 99                                                   112 
100     G4ProcessManager(const G4ParticleDefinitio << 113   private:
101       //  Constructor                          << 114       // hide default constructor and assignment operator
                                                   >> 115       G4ProcessManager & operator=(G4ProcessManager &right);
                                                   >> 116       G4ProcessManager();
102                                                   117 
103     G4ProcessManager(G4ProcessManager& right); << 
104       // copy constructor                      << 
105                                                   118 
106     G4ProcessManager() = delete;               << 119   public:
107     G4ProcessManager& operator=(const G4Proces << 120  
108       // Default constructor and assignment op << 121       G4ProcessManager(const G4ParticleDefinition* aParticleType);
                                                   >> 122       //  Constructor
109                                                   123 
110     ~G4ProcessManager();                       << 124       ~G4ProcessManager();
111       // Destructor                            << 125       //  Destructor
112                                                   126 
113     G4bool operator==(const G4ProcessManager & << 127       G4int operator==(const G4ProcessManager &right) const;
114     G4bool operator!=(const G4ProcessManager & << 128       G4int operator!=(const G4ProcessManager &right) const;
115                                                   129 
116     inline G4ProcessVector* GetProcessList() c << 130  public: //  with description
117       // Returns the address of the vector of  << 131       G4ProcessVector* GetProcessList() const;
                                                   >> 132       //  Returns the address of the vector of all processes 
118                                                   133 
119     inline G4int GetProcessListLength() const; << 134       G4int  GetProcessListLength() const;
120       // Returns the number of process in the  << 135       //  Returns the number of process in the ProcessVector 
121                                                   136 
122     inline G4int GetProcessIndex(G4VProcess*)  << 137       G4int GetProcessIndex(G4VProcess *) const;
123       // Returns the index of the process in t << 138       //  Returns the index of the process in the process List
124                                                   139 
125     inline G4ProcessVector* GetProcessVector(  << 140       // --------------------------------------
126                                G4ProcessVector << 141 
127                                G4ProcessVector << 142       G4ProcessVector* GetProcessVector( 
128                               ) const;         << 143              G4ProcessVectorDoItIndex idx,
129       // Returns the address of the vector of  << 144              G4ProcessVectorTypeIndex typ = typeGPIL
                                                   >> 145             ) const;
                                                   >> 146       //  Returns the address of the vector of processes 
130                                                   147 
131     inline G4ProcessVector* GetAtRestProcessVe << 148       G4ProcessVector* GetAtRestProcessVector(
132                                G4ProcessVector << 149              G4ProcessVectorTypeIndex typ = typeGPIL
133                               ) const;            150                               ) const; 
134       // Returns the address of the vector of  << 151       //  Returns the address of the vector of processes for
135       //    AtRestGetPhysicalInteractionLength    152       //    AtRestGetPhysicalInteractionLength      idx =0
136       //    AtRestGetPhysicalDoIt                 153       //    AtRestGetPhysicalDoIt                   idx =1
137                                                << 154       G4ProcessVector* GetAlongStepProcessVector(
138     inline G4ProcessVector* GetAlongStepProces << 155              G4ProcessVectorTypeIndex typ = typeGPIL
139                                G4ProcessVector << 
140                               ) const;            156                               ) const;
141       // Returns the address of the vector of  << 157       //  Returns the address of the vector of processes for
142       //    AlongStepGetPhysicalInteractionLen    158       //    AlongStepGetPhysicalInteractionLength      idx =0
143       //    AlongStepGetPhysicalDoIt              159       //    AlongStepGetPhysicalDoIt                   idx =1
144                                                   160 
145     inline G4ProcessVector* GetPostStepProcess << 161       G4ProcessVector* GetPostStepProcessVector(
146                                G4ProcessVector << 162              G4ProcessVectorTypeIndex typ = typeGPIL
147                               ) const;            163                               ) const;
148       // Returns the address of the vector of  << 164       //  Returns the address of the vector of processes for
149       //    PostStepGetPhysicalInteractionLeng    165       //    PostStepGetPhysicalInteractionLength      idx =0
150       //    PostStepGetPhysicalDoIt               166       //    PostStepGetPhysicalDoIt                   idx =1
151                                                   167 
152     G4int GetProcessVectorIndex(               << 168       G4int GetProcessVectorIndex(
153                            G4VProcess* aProces << 
154                            G4ProcessVectorDoIt << 
155                            G4ProcessVectorType << 
156                            ) const;            << 
157     inline G4int GetAtRestIndex(               << 
158                            G4VProcess* aProces    169                            G4VProcess* aProcess,
159                            G4ProcessVectorType << 170          G4ProcessVectorDoItIndex idx,
160                            ) const;            << 171          G4ProcessVectorTypeIndex typ  = typeGPIL
161     inline G4int GetAlongStepIndex(            << 172          ) const;
                                                   >> 173       G4int GetAtRestIndex(
162                            G4VProcess* aProces    174                            G4VProcess* aProcess,
163                            G4ProcessVectorType << 175          G4ProcessVectorTypeIndex typ  = typeGPIL
164                            ) const;            << 176          ) const;
165     inline G4int GetPostStepIndex(             << 177       G4int GetAlongStepIndex(
166                            G4VProcess* aProces    178                            G4VProcess* aProcess,
167                            G4ProcessVectorType << 179          G4ProcessVectorTypeIndex typ  = typeGPIL
168                            ) const;            << 180          ) const;
169       // Returns the index for GPIL/DoIt proce << 181       G4int GetPostStepIndex(
170                                                << 182          G4VProcess* aProcess,
171     G4int AddProcess( G4VProcess* aProcess,    << 183          G4ProcessVectorTypeIndex typ = typeGPIL
172                       G4int ordAtRestDoIt = or << 184          ) const;
173                       G4int ordAlongSteptDoIt  << 185       //  Returns the index for GPIL/DoIt process vector of the process  
174                       G4int ordPostStepDoIt =  << 186 
175       // Adds a process to the process List    << 187       G4int AddProcess(
176       // Return values is the index to the Lis << 188              G4VProcess *aProcess,
177       // indicates that the process has not be << 189              G4int      ordAtRestDoIt = ordInActive,
178       // The first argument is a pointer to th << 190              G4int      ordAlongSteptDoIt = ordInActive,
179       // Successive arguments are ordering par << 191              G4int      ordPostStepDoIt = ordInActive
180       // process vectors. If value is negative << 192             );
181       // not added to the corresponding proces << 193       //  Add a process to the process List
                                                   >> 194       //  return values are index to the List. Negative return value 
                                                   >> 195       //  indicates that the process has not be added due to some errors
                                                   >> 196       //  The first argument is a pointer to process.
                                                   >> 197       //  Following arguments are ordering parameters of the process in 
                                                   >> 198       //  process vectors. If value is negative, the process is
                                                   >> 199       //  not added to the corresponding process vector. 
182                                                   200    
183     ////////////////////////////////////////// << 201       //  following methods are provided for simple processes  
184     // The following methods are provided for  << 202       //   AtRestProcess has only AtRestDoIt
185     //   AtRestProcess has only AtRestDoIt     << 203       //   ContinuousProcess has only AlongStepDoIt
186     //   ContinuousProcess has only AlongStepD << 204       //   DiscreteProcess has only PostStepDoIt
187     //   DiscreteProcess has only PostStepDoIt << 205       //  If the ording parameter is not specified, the process is
188     // If the ordering parameter is not specif << 206       //  added at the end of List of process vectors 
189     // added at the end of List of process vec << 207       //  If a process with same ordering parameter exists, 
190     // If a process with same ordering paramet << 208       //   this new process will be added just after processes 
191     // this new process will be added just aft << 209       //   with same ordering parameter  
192     // with same ordering parameter (except fo << 210       //  (except for processes assigned to LAST explicitly )
193     // explicitly) for both DoIt() and GetPhys << 211       //  for both DoIt and GetPhysicalInteractionLength
194     ////////////////////////////////////////// << 212       //  
195                                                << 213 
196     inline G4int AddRestProcess(G4VProcess* aP << 214       G4int AddRestProcess(G4VProcess *aProcess, G4int ord = ordDefault);
197     inline G4int AddDiscreteProcess(G4VProcess << 215       G4int AddDiscreteProcess(G4VProcess *aProcess, G4int ord = ordDefault);
198     inline G4int AddContinuousProcess(G4VProce << 216       G4int AddContinuousProcess(G4VProcess *aProcess, G4int ord = ordDefault);
199                                                << 217 
200     ////////////////////////////////////////// << 218 
201     // Alternative methods for setting orderin << 219        /////////////////////////////////////////////// 
202     // Note: AddProcess() method should preced << 220       // Methods for setting ordering parameters
203     ////////////////////////////////////////// << 221       // Altanative methods for setting ordering parameters 
204                                                << 222       //   Note: AddProcess method should precede these methods
205     G4int GetProcessOrdering(                  << 223 
206                             G4VProcess* aProce << 224       G4int GetProcessOrdering(
207                             G4ProcessVectorDoI << 225              G4VProcess *aProcess,
208                             );                 << 226              G4ProcessVectorDoItIndex idDoIt
209                                                << 227                                );
210     void SetProcessOrdering(                   << 228 
211                             G4VProcess* aProce << 229       void SetProcessOrdering(
212                             G4ProcessVectorDoI << 230              G4VProcess *aProcess,
213                             G4int ordDoIt = or << 231              G4ProcessVectorDoItIndex idDoIt,
214                            );                  << 232              G4int      ordDoIt = ordDefault
215       // Set ordering parameter for DoIt() spe << 233                                );
                                                   >> 234       // Set ordering parameter for DoIt specified by typeDoIt.
216       // If a process with same ordering param    235       // If a process with same ordering parameter exists, 
217       // this new process will be added just a    236       // this new process will be added just after processes 
218       // with same ordering parameter             237       // with same ordering parameter  
219       // Note: Ordering parameter will bet set    238       // Note: Ordering parameter will bet set to non-zero 
220       //       even if you set ordDoIt = 0     << 239       //       even if you set  ordDoIt = 0
221                                                   240             
222     void SetProcessOrderingToFirst(            << 241      void SetProcessOrderingToFirst(
223                             G4VProcess* aProce << 242              G4VProcess *aProcess,
224                             G4ProcessVectorDoI << 243              G4ProcessVectorDoItIndex idDoIt
225                            );                  << 244              );
226       // Set ordering parameter to the first o    245       // Set ordering parameter to the first of all processes 
227       // for DoIt() specified by idDoIt.       << 246       // for DoIt specified by idDoIt.
228       // Note: If you use this method for two  << 247       //  Note: If you use this method for two processes,
229       //       a process called later will be  << 248       //        a process called later will be first.
230                                                << 249 
231     void SetProcessOrderingToSecond(           << 250       void SetProcessOrderingToSecond(
232                             G4VProcess* aProce << 251              G4VProcess *aProcess,
233                             G4ProcessVectorDoI << 252              G4ProcessVectorDoItIndex idDoIt
234                            );                  << 253              );
235       // Set ordering parameter to 1 for DoIt( << 254       // Set ordering parameter to 1 for DoIt specified by idDoIt
236       // and the process will be added just af << 255       // and the rpocess will be added just after 
237       // the processes with ordering parameter    256       // the processes with ordering parameter equal to zero
238       // Note: If you use this method for two  << 257       //  Note: If you use this method for two processes,
239       //       a process called later will be  << 258       //        a process called later will be .
240                                                   259 
241     void SetProcessOrderingToLast(             << 260         void SetProcessOrderingToLast(
242                             G4VProcess* aProce << 261              G4VProcess *aProcess,
243                             G4ProcessVectorDoI << 262              G4ProcessVectorDoItIndex idDoIt
244                            );                  << 263              );
245       // Set ordering parameter to the last of    264       // Set ordering parameter to the last of all processes 
246       // for DoIt() specified by idDoIt.       << 265       // for DoIt specified by idDoIt.
247       // Note: If you use this method for two  << 266       //  Note: If you use this method for two processes,
248       //       a process called later will pre << 267       //        a process called later will precede.
249                                                << 268 
250     ////////////////////////////////////////// << 269       G4VProcess*  RemoveProcess(G4VProcess *aProcess);
251                                                << 270       G4VProcess*  RemoveProcess(G4int      index);
252     G4VProcess* RemoveProcess(G4VProcess* aPro << 271       //  Removes a process from the process List.
253     G4VProcess* RemoveProcess(G4int index);    << 272       //  return value is pointer to the removed process.
254       // Removes a process from the process Li << 273       //  (0 value will be returned in case of errors)
255       // Returns pointer to the removed proces << 274 
256       // (nullptr value will be returned in ca << 275       G4VProcess* SetProcessActivation(G4VProcess *aProcess, G4bool fActive);
257                                                << 276       G4VProcess* SetProcessActivation(G4int      index, G4bool fActive);
258     G4VProcess* SetProcessActivation(G4VProces << 277       //  Set activation flag. 
259     G4VProcess* SetProcessActivation(G4int ind << 278       //  return value is pointer to the applied process.
260       // Set activation flag.                  << 279       //  (0 value will be returned in case of errors)
261       // Returns pointer to the applied proces << 280 
262       // (nullptr value will be returned in ca << 281       G4bool GetProcessActivation(G4VProcess *aProcess) const;
263                                                << 282       G4bool GetProcessActivation(G4int      index) const;
264     G4bool GetProcessActivation(G4VProcess* aP << 283       //  Get activation flag. 
265     G4bool GetProcessActivation(G4int index) c << 284 
266       // Get activation flag.                  << 285       G4ParticleDefinition*  GetParticleType() const;
267                                                << 286       // get the particle type 
268     inline G4ParticleDefinition* GetParticleTy << 287       void SetParticleType(const G4ParticleDefinition*);
269       // Get the particle type                 << 288       // set the particle type 
270     inline void SetParticleType(const G4Partic << 289 
271       // Set the particle type                 << 290       void StartTracking(G4Track* aTrack=0);
272                                                << 291       void EndTracking();
273     G4VProcess* GetProcess (const G4String&) c << 292       // these two methods are used by G4TrackingManager 
274       // Get process by process name           << 
275                                                << 
276     void StartTracking(G4Track* aTrack = nullp << 
277     void EndTracking();                        << 
278       // These two methods are used by G4Track << 
279       // in order to inform Start/End of track    293       // in order to inform Start/End of tracking for each track
280       // to the process manager and all physic << 294       // to the process manager and all physics processes 
281                                                << 
282     void DumpInfo();                           << 
283                                                << 
284     inline void SetVerboseLevel(G4int value);  << 
285     inline G4int GetVerboseLevel() const;      << 
286       // Control flag for output message       << 
287       //  0: Silent                            << 
288       //  1: Warning message                   << 
289       //  2: More                              << 
290                                                   295 
291     enum {SizeOfProcVectorArray = 6};          << 
292                                                   296 
                                                   >> 297   public:
                                                   >> 298       enum {SizeOfProcVectorArray = 6};
293   private:                                        299   private:
                                                   >> 300       G4ProcessVector* theProcVector[SizeOfProcVectorArray];
                                                   >> 301       // vector for processes with GetPhysicalInteractionLength/DoIt
294                                                   302 
295     G4int InsertAt(G4int position, G4VProcess* << 303       typedef std::vector<G4ProcessAttribute*> G4ProcessAttrVector; 
296       // Insert process at position in theProc << 304       G4ProcessAttrVector*  theAttrVector;
                                                   >> 305       // vector for process attribute  
                                                   >> 306 
                                                   >> 307   protected: // with description
                                                   >> 308       G4int InsertAt(G4int position, G4VProcess* process, G4int ivec);
                                                   >> 309       // insert process at position in theProcVector[ivec]
297                                                   310 
298     G4int RemoveAt(G4int position, G4VProcess* << 311       G4int RemoveAt(G4int position, G4VProcess* process, G4int ivec);
299       // Remove process at position in theProc << 312       // remove process at position in theProcVector[ivec]
300                                                   313 
301     G4int FindInsertPosition(G4int ord, G4int  << 314       G4int FindInsertPosition(G4int ord, G4int ivec);
302       // Find insert position according to ord << 315       // find insert position according to ordering parameter 
303       // in theProcVector[ivec]                   316       // in theProcVector[ivec]
304                                                   317 
305     inline G4int GetProcessVectorId(G4ProcessV << 318       G4int GetProcessVectorId(G4ProcessVectorDoItIndex idx,
306                              G4ProcessVectorTy << 319              G4ProcessVectorTypeIndex typ  = typeGPIL) const;
307                                                   320 
308     void CheckOrderingParameters(G4VProcess*)  << 321   void CheckOrderingParameters(G4VProcess*) const;
309       // Check consistencies between ordering  << 322        // check consistencies between ordering parameters and 
310       // validity of DoIt() of the Process     << 323        // validity of DoIt of the Process 
311                                                << 324 
312     G4ProcessAttribute* GetAttribute(G4int ind << 325   private:     
313     G4ProcessAttribute* GetAttribute(G4VProces << 326       G4ProcessAttribute* GetAttribute(G4int      index) const;
314       // Get Pointer to ProcessAttribute       << 327       G4ProcessAttribute* GetAttribute(G4VProcess *aProcess) const;
315                                                << 328       // get Pointer to ProcessAttribute
316     void  CreateGPILvectors();                 << 329 
317     void  SetIndexToProcessVector(G4int ivec); << 330       G4VProcess* ActivateProcess(G4int   index);
318                                                << 331       G4VProcess* InActivateProcess(G4int  index);
319     G4VProcess* ActivateProcess(G4int index);  << 332       // Activate/InActivateProcess   Process
320     G4VProcess* InActivateProcess(G4int index) << 
321       // Activate/InActivate process           << 
322                                                   333       
323   private:                                     << 334   private:     
324                                                << 335       const G4ParticleDefinition*   theParticleType;
325     G4ProcessVector* theProcVector[SizeOfProcV << 336       //  particle which has this process manager object     
326       // Vector for processes with GetPhysical << 337 
327                                                << 338       G4int             numberOfProcesses;
328     G4ProcessAttrVector* theAttrVector = nullp << 339       G4ProcessVector*  theProcessList;
329       // Vector for process attribute          << 340       // vector for all processes (called as "process List")
                                                   >> 341 
                                                   >> 342  private:
                                                   >> 343       G4bool  duringTracking;
                                                   >> 344       void    CreateGPILvectors();
                                                   >> 345       void    SetIndexToProcessVector(G4int ivec);
                                                   >> 346 
                                                   >> 347  public: // with description
                                                   >> 348    void  DumpInfo();
                                                   >> 349 
                                                   >> 350    void  SetVerboseLevel(G4int value);
                                                   >> 351    G4int GetVerboseLevel() const;
                                                   >> 352    // controle flag for output message
                                                   >> 353    //  0: Silent
                                                   >> 354    //  1: Warning message
                                                   >> 355    //  2: More
330                                                   356 
331     const G4ParticleDefinition* theParticleTyp << 357  protected:
332       // Particle which has this process manag << 358    G4int verboseLevel;
333                                                << 
334     G4int numberOfProcesses = 0;               << 
335     G4ProcessVector* theProcessList = nullptr; << 
336       // Vector for all processes (called as " << 
337                                                << 
338     G4bool duringTracking = false;             << 
339                                                << 
340     G4bool isSetOrderingFirstInvoked[NDoit];   << 
341     G4bool isSetOrderingLastInvoked[NDoit];    << 
342                                                << 
343     G4int verboseLevel = 1;                    << 
344                                                   359   
345     static G4ThreadLocal G4ProcessManagerMesse << 360  private:
346     static G4ThreadLocal G4int counterOfObject << 361    static G4ProcessManagerMessenger* fProcessManagerMessenger;
                                                   >> 362    static G4int                      counterOfObjects;
347 };                                                363 };
348                                                << 
349 #include "G4ProcessManager.icc"                   364 #include "G4ProcessManager.icc"
350                                                   365 
351 #endif                                            366 #endif
                                                   >> 367 
352                                                   368