Geant4 Cross Reference

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


                                                   >>   1 
                                                   >>   2 // This code implementation is the intellectual property of
                                                   >>   3 // the GEANT4 collaboration.
                                                   >>   4 //
                                                   >>   5 // By copying, distributing or modifying the Program (or any work
                                                   >>   6 // based on the Program) you indicate your acceptance of this statement,
                                                   >>   7 // and all its terms.
                                                   >>   8 //
                                                   >>   9 // $Id: G4ProcessTable.hh,v 1.6 2000/03/02 01:16:05 kurasige Exp $
                                                   >>  10 // GEANT4 tag $Name: geant4-03-01 $
                                                   >>  11 //
                                                   >>  12 // 
                                                   >>  13 // ------------------------------------------------------------
                                                   >>  14 //  GEANT 4 class header file 
                                                   >>  15 //
                                                   >>  16 //  For information related to this code contact:
                                                   >>  17 //  CERN, IT Division, ASD group
                                                   >>  18 //  History: first implementation, based on object model of
                                                   >>  19 //  4th Aug 1998, H.Kurashige
                                                   >>  20 //
                                                   >>  21 // Class Description
                                                   >>  22 //  This class is used for "book keeping" of all processes 
                                                   >>  23 //  which are registered in all particles
  1 //                                                 24 //
  2 // ******************************************* <<  25 //  History:
  3 // * License and Disclaimer                    <<  26 //   Added G4ProcessTableMesseneger         16 Aug. 1998, H.Kurashige
  4 // *                                           <<  27 //   Use STL vector instead of RW vector    1. Mar 00 H.Kurashige
  5 // * The  Geant4 software  is  copyright of th <<  28 //
  6 // * the Geant4 Collaboration.  It is provided <<  29 // ------------------------------------------------------------
  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 //                                             << 
 26 // G4ProcessTable                              << 
 27 //                                             << 
 28 // Class description:                          << 
 29 //                                             << 
 30 // This class is used for "book keeping" of al << 
 31 // which are registered for all particles      << 
 32                                                << 
 33 // Author: H.Kurashige, 4 August 1998          << 
 34 // ------------------------------------------- << 
 35 #ifndef G4ProcessTable_hh                      << 
 36 #define G4ProcessTable_hh 1                    << 
 37                                                    30 
 38 #include <vector>                              <<  31 #ifndef G4ProcessTable_h
                                                   >>  32 #define G4ProcessTable_h 1
 39                                                    33 
 40 #include "globals.hh"                              34 #include "globals.hh"
                                                   >>  35 #include "G4ios.hh"
                                                   >>  36 #include "g4std/vector"
                                                   >>  37 
 41 #include "G4ProcTblElement.hh"                     38 #include "G4ProcTblElement.hh"
 42 #include "G4ProcessVector.hh"                      39 #include "G4ProcessVector.hh"
 43 #include "G4ThreadLocalSingleton.hh"           << 
 44                                                << 
 45 class G4UImessenger;                           << 
 46 class G4ProcessTableMessenger;                     40 class G4ProcessTableMessenger;
 47                                                    41 
 48 class G4ProcessTable                               42 class G4ProcessTable
 49 {                                                  43 {
 50   friend class G4ThreadLocalSingleton<G4Proces <<  44  public:
 51                                                <<  45   G4ProcessTable();
 52   public:                                      <<  46   //  Constructors
 53                                                <<  47   
 54     using G4ProcTableVector = std::vector<G4Pr <<  48   ~G4ProcessTable();
 55     using G4ProcNameVector = std::vector<G4Str <<  49   //  Destructor
 56                                                <<  50   
 57     ~G4ProcessTable();                         <<  51  private:
 58       // Destructor                            <<  52   G4ProcessTable(const G4ProcessTable &right);
                                                   >>  53   G4ProcessTable & operator=(const G4ProcessTable &right);
                                                   >>  54   // Assignment operator
                                                   >>  55   G4int operator==(const G4ProcessTable &right) const;
                                                   >>  56   G4int operator!=(const G4ProcessTable &right) const;
                                                   >>  57   // equal / unequal operator
 59                                                    58   
 60     G4ProcessTable(const G4ProcessTable&) = de << 
 61     G4ProcessTable& operator=(const G4ProcessT << 
 62     G4bool operator==(const G4ProcessTable &ri << 
 63     G4bool operator!=(const G4ProcessTable &ri << 
 64       // Copy constructor and operators not al << 
 65                                                << 
 66     static G4ProcessTable* GetProcessTable();  << 
 67       // Return the pointer to the G4ProcessTa << 
 68       // As "singleton" one can get the instan << 
 69                                                << 
 70     inline G4int Length() const;               << 
 71       // Return the number of processes in the << 
 72                                                << 
 73     G4int Insert(G4VProcess* aProcess, G4Proce << 
 74     G4int Remove(G4VProcess* aProcess, G4Proce << 
 75       // Each process object is registered wit << 
 76       // managers that use it                  << 
 77                                                << 
 78     G4VProcess* FindProcess(const G4String& pr << 
 79                             const G4String& pa << 
 80     inline G4VProcess* FindProcess(const G4Str << 
 81                                    const G4Par << 
 82     G4VProcess* FindProcess(const G4String& pr << 
 83                             const G4ProcessMan << 
 84     G4VProcess* FindProcess(G4ProcessType proc << 
 85                             const G4ParticleDe << 
 86     G4VProcess* FindProcess(G4int processSubTy << 
 87                             const G4ParticleDe << 
 88       // Return the process pointer            << 
 89                                                << 
 90     void RegisterProcess(G4VProcess*);         << 
 91     void DeRegisterProcess(G4VProcess*);       << 
 92       // Implementation of registration mechan << 
 93                                                << 
 94     inline G4ProcessVector* FindProcesses();   << 
 95     inline G4ProcessVector* FindProcesses( con << 
 96     inline G4ProcessVector* FindProcesses( con << 
 97     inline G4ProcessVector* FindProcesses( G4P << 
 98       // Return pointer of a process vector wh << 
 99       // Note: user is responsible to delete t << 
100                                                << 
101     void SetProcessActivation( const G4String& << 
102                                G4bool          << 
103     void SetProcessActivation( const G4String& << 
104                                const G4String& << 
105                                G4bool          << 
106     inline void SetProcessActivation( const G4 << 
107                                       const G4 << 
108                                       G4bool   << 
109     void SetProcessActivation( const G4String& << 
110                                G4ProcessManage << 
111                                G4bool          << 
112     void SetProcessActivation( G4ProcessType   << 
113                                G4bool          << 
114     void SetProcessActivation( G4ProcessType   << 
115                                const G4String& << 
116                                G4bool          << 
117     inline void SetProcessActivation( G4Proces << 
118                                       const G4 << 
119                                       G4bool   << 
120     void SetProcessActivation( G4ProcessType   << 
121                                G4ProcessManage << 
122                                G4bool          << 
123       // These methods are provided to activat << 
124                                                << 
125     inline G4ProcNameVector* GetNameList();    << 
126       // Return pointer of the list of process << 
127                                                << 
128     inline G4ProcTableVector* GetProcTableVect << 
129       // Return pointer of the vector of G4Pro << 
130                                                << 
131     void DumpInfo(G4VProcess* process,         << 
132                   const G4ParticleDefinition*  << 
133       // Dump out information of the process t << 
134       // is used to specify processes designat << 
135                                                << 
136     inline void  SetVerboseLevel(G4int value); << 
137     inline G4int GetVerboseLevel() const;      << 
138       // Set/Get control flag for output messa << 
139       //  0: Silent                            << 
140       //  1: Warning message                   << 
141       //  2: More                              << 
142                                                << 
143   private:                                     << 
144                                                << 
145     G4ProcessTable();                          << 
146       // Private default constructor           << 
147                                                << 
148     G4ProcTableVector* Find(const G4String& pr << 
149     G4ProcTableVector* Find(G4ProcessType   pr << 
150       // Return pointer of a ProcTableVector w << 
151       // ProcTbleElement specified             << 
152                                                << 
153     G4ProcessVector* ExtractProcesses(G4ProcTa << 
154       // Extract all process objects from the  << 
155                                                    59  
156   private:                                     <<  60  public: // with description
                                                   >>  61   static G4ProcessTable* GetProcessTable();
                                                   >>  62   // return the pointer to G4ProcessTable object
                                                   >>  63   //   G4ProcessTable is a "singleton" and can get its pointer by this function
                                                   >>  64 
                                                   >>  65   G4int  Length() const;
                                                   >>  66   // return the number of processes in the table
                                                   >>  67 
                                                   >>  68   G4int  Insert(G4VProcess* aProcess, G4ProcessManager* aProcMgr);
                                                   >>  69   G4int  Remove(G4VProcess* aProcess, G4ProcessManager* aProcMgr);  
                                                   >>  70   // insert and remove methods
                                                   >>  71   //  each process object is registered with information of process managers
                                                   >>  72   //  that use it.
                                                   >>  73 
                                                   >>  74   G4VProcess* FindProcess(const G4String& processName, 
                                                   >>  75         const G4String& particleName) const;
                                                   >>  76   G4VProcess* FindProcess(const G4String& processName, 
                                                   >>  77         const G4ParticleDefinition* particle) const;
                                                   >>  78   G4VProcess* FindProcess(const G4String& processName, 
                                                   >>  79         const G4ProcessManager* processManager) const;
                                                   >>  80   // return the process pointer   
                                                   >>  81   
                                                   >>  82   G4ProcessVector* FindProcesses();
                                                   >>  83   G4ProcessVector* FindProcesses( const G4ProcessManager* processManager );
                                                   >>  84   G4ProcessVector* FindProcesses( const G4String& processName );
                                                   >>  85   G4ProcessVector* FindProcesses( G4ProcessType   processType );
                                                   >>  86   // return pointer of a process vector 
                                                   >>  87   //  which includes processes specified
                                                   >>  88   //  Note:: User is responsible to delete this process vector object  
                                                   >>  89 
                                                   >>  90   void SetProcessActivation( const G4String& processName, 
                                                   >>  91            G4bool          fActive);
                                                   >>  92   void SetProcessActivation( const G4String& processName, 
                                                   >>  93                  const G4String& particleName, 
                                                   >>  94            G4bool          fActive );
                                                   >>  95   void SetProcessActivation( const G4String& processName, 
                                                   >>  96                  G4ParticleDefinition* particle, 
                                                   >>  97            G4bool          fActive );
                                                   >>  98   void SetProcessActivation( const G4String& processName, 
                                                   >>  99                  G4ProcessManager* processManager, 
                                                   >> 100            G4bool          fActive  );
                                                   >> 101   void SetProcessActivation( G4ProcessType   processType, 
                                                   >> 102            G4bool          fActive  );
                                                   >> 103   void SetProcessActivation( G4ProcessType   processType,
                                                   >> 104                  const G4String& particleName, 
                                                   >> 105            G4bool          fActive  );
                                                   >> 106   void SetProcessActivation( G4ProcessType   processType,
                                                   >> 107                  G4ParticleDefinition* particle, 
                                                   >> 108            G4bool          fActive );
                                                   >> 109   void SetProcessActivation( G4ProcessType   processType,
                                                   >> 110                  G4ProcessManager* processManager, 
                                                   >> 111            G4bool          fActive  );
                                                   >> 112   // These methods are provided to activate or inactivate processes
                                                   >> 113 
                                                   >> 114  public:
                                                   >> 115   typedef G4std::vector<G4ProcTblElement*>  G4ProcTableVector;
                                                   >> 116   typedef G4std::vector<G4String> G4ProcNameVector;
                                                   >> 117 
                                                   >> 118  public: // with description
                                                   >> 119   G4ProcNameVector*  GetNameList();
                                                   >> 120   // return pointer of the list of process name
157                                                   121 
158     static G4ThreadLocal G4ProcessTable* fProc << 122   G4ProcTableVector* GetProcTableVector();
159     G4ProcessTableMessenger* fProcTblMessenger << 123   // return pointer of the vector of G4ProcTblElement
                                                   >> 124   
                                                   >> 125  private:
                                                   >> 126   G4ProcTableVector* Find(  G4ProcTableVector* procTableVector,
                                                   >> 127           const G4String& processName );
                                                   >> 128   G4ProcTableVector* Find(  G4ProcTableVector* procTableVector,
                                                   >> 129           G4ProcessType   processType );
                                                   >> 130   // return pointer of a ProcTableVector 
                                                   >> 131   //  which includes ProcTbleElement specified
160                                                   132 
161     G4ProcTableVector* fProcTblVector = nullpt << 133   G4ProcessVector*   ExtractProcesses( G4ProcTableVector* procTableVector);
162     G4ProcNameVector* fProcNameVector = nullpt << 134   // extract all process objects from the process table 
                                                   >> 135  
                                                   >> 136  public: // with description
                                                   >> 137   void DumpInfo(G4VProcess* process, G4ParticleDefinition* particle=0);
                                                   >> 138   // dump out information of the process table
                                                   >> 139   //  second argument is used to specify processes designated by a particle 
                                                   >> 140   
                                                   >> 141  public: // with description
                                                   >> 142    G4UImessenger* CreateMessenger();
                                                   >> 143    void           DeleteMessenger();
                                                   >> 144    // These methods are used by RunManager to let the process table
                                                   >> 145    // know the timing of creation/destructuion of  messengers
163                                                   146   
164     G4ProcTableVector* tmpTblVector = nullptr; << 147  public: // with description
165       // Used only internally as temporary buf << 148    void  SetVerboseLevel(G4int value);
                                                   >> 149    G4int GetVerboseLevel() const;
                                                   >> 150    // Set/Get controle flag for output message
                                                   >> 151    //  0: Silent
                                                   >> 152    //  1: Warning message
                                                   >> 153    //  2: More
                                                   >> 154 
                                                   >> 155 
                                                   >> 156  private:
                                                   >> 157   static G4ProcessTable*    fProcessTable;
                                                   >> 158   G4ProcessTableMessenger*   fProcTblMessenger;
                                                   >> 159 
                                                   >> 160  private:
                                                   >> 161   G4ProcTableVector*        fProcTblVector;
                                                   >> 162   G4ProcNameVector*         fProcNameVector;
                                                   >> 163   // list of G4ProcTblElement
                                                   >> 164   
                                                   >> 165   G4ProcTableVector*        tmpTblVector;
                                                   >> 166   // used only internaly for temporary buffer.
166                                                   167 
167     std::vector<G4VProcess*> fListProcesses;   << 168  private:
168       // Used for registration of process inst << 169    G4int verboseLevel;
                                                   >> 170    // controle flag for output message
169                                                   171 
170     G4int verboseLevel = 1;                    << 
171       // Control flag for output message       << 
172 };                                                172 };
173                                                   173 
174 #include "G4ProcessTable.icc"                     174 #include "G4ProcessTable.icc"
175                                                << 
176 #endif                                            175 #endif
177                                                   176