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 10.6)


  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 // G4ProcessTable                              <<  26 
                                                   >>  27 //
                                                   >>  28 //
                                                   >>  29 // 
                                                   >>  30 // ------------------------------------------------------------
                                                   >>  31 //  GEANT 4 class header file 
                                                   >>  32 //
                                                   >>  33 //  History: first implementation, based on object model of
                                                   >>  34 //  4th Aug 1998, H.Kurashige
                                                   >>  35 //
                                                   >>  36 // Class Description
                                                   >>  37 //  This class is used for "book keeping" of all processes 
                                                   >>  38 //  which are registered in all particles
 27 //                                                 39 //
 28 // Class description:                          <<  40 //  History:
                                                   >>  41 //   Added G4ProcessTableMesseneger         16 Aug. 1998, H.Kurashige
                                                   >>  42 //   Use STL vector instead of RW vector    1. Mar 00 H.Kurashige
 29 //                                                 43 //
 30 // This class is used for "book keeping" of al <<  44 // ------------------------------------------------------------
 31 // which are registered for all particles      << 
 32                                                    45 
 33 // Author: H.Kurashige, 4 August 1998          <<  46 #ifndef G4ProcessTable_h
 34 // ------------------------------------------- <<  47 #define G4ProcessTable_h 1
 35 #ifndef G4ProcessTable_hh                      << 
 36 #define G4ProcessTable_hh 1                    << 
 37                                                    48 
                                                   >>  49 #include "globals.hh"
                                                   >>  50 #include "G4ios.hh"
 38 #include <vector>                                  51 #include <vector>
 39                                                    52 
 40 #include "globals.hh"                          << 
 41 #include "G4ProcTblElement.hh"                     53 #include "G4ProcTblElement.hh"
 42 #include "G4ProcessVector.hh"                      54 #include "G4ProcessVector.hh"
 43 #include "G4ThreadLocalSingleton.hh"               55 #include "G4ThreadLocalSingleton.hh"
 44                                                    56 
 45 class G4UImessenger;                               57 class G4UImessenger;
 46 class G4ProcessTableMessenger;                     58 class G4ProcessTableMessenger;
 47                                                    59 
 48 class G4ProcessTable                               60 class G4ProcessTable
 49 {                                                  61 {
 50   friend class G4ThreadLocalSingleton<G4Proces << 
 51                                                    62 
 52   public:                                      <<  63 friend class G4ThreadLocalSingleton<G4ProcessTable>;
 53                                                    64 
 54     using G4ProcTableVector = std::vector<G4Pr <<  65  public:
 55     using G4ProcNameVector = std::vector<G4Str <<  66   G4ProcessTable();
 56                                                <<  67   //  Constructors
 57     ~G4ProcessTable();                         <<  68   
 58       // Destructor                            <<  69   ~G4ProcessTable();
                                                   >>  70   //  Destructor
                                                   >>  71   
                                                   >>  72  private:
                                                   >>  73   G4ProcessTable(const G4ProcessTable &right);
                                                   >>  74   G4ProcessTable & operator=(const G4ProcessTable &right);
                                                   >>  75   // Assignment operator
                                                   >>  76   G4bool operator==(const G4ProcessTable &right) const;
                                                   >>  77   G4bool operator!=(const G4ProcessTable &right) const;
                                                   >>  78   // equal / unequal operator
 59                                                    79   
 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                                                    80  
156   private:                                     <<  81  public: // with description
                                                   >>  82   static G4ProcessTable* GetProcessTable();
                                                   >>  83   // return the pointer to G4ProcessTable object
                                                   >>  84   //   G4ProcessTable is a "singleton" and can get its pointer by this function
                                                   >>  85 
                                                   >>  86   G4int  Length() const;
                                                   >>  87   // return the number of processes in the table
                                                   >>  88 
                                                   >>  89   G4int  Insert(G4VProcess* aProcess, G4ProcessManager* aProcMgr);
                                                   >>  90   G4int  Remove(G4VProcess* aProcess, G4ProcessManager* aProcMgr);  
                                                   >>  91   // insert and remove methods
                                                   >>  92   //  each process object is registered with information of process managers
                                                   >>  93   //  that use it.
                                                   >>  94 
                                                   >>  95   G4VProcess* FindProcess(const G4String& processName, 
                                                   >>  96         const G4String& particleName) const;
                                                   >>  97   G4VProcess* FindProcess(const G4String& processName, 
                                                   >>  98         const G4ParticleDefinition* particle) const;
                                                   >>  99   G4VProcess* FindProcess(const G4String& processName, 
                                                   >> 100         const G4ProcessManager* processManager) const;
                                                   >> 101   // return the process pointer   
                                                   >> 102   
                                                   >> 103   G4ProcessVector* FindProcesses();
                                                   >> 104   G4ProcessVector* FindProcesses( const G4ProcessManager* processManager );
                                                   >> 105   G4ProcessVector* FindProcesses( const G4String& processName );
                                                   >> 106   G4ProcessVector* FindProcesses( G4ProcessType   processType );
                                                   >> 107   // return pointer of a process vector 
                                                   >> 108   //  which includes processes specified
                                                   >> 109   //  Note:: User is responsible to delete this process vector object  
                                                   >> 110 
                                                   >> 111   void SetProcessActivation( const G4String& processName, 
                                                   >> 112            G4bool          fActive);
                                                   >> 113   void SetProcessActivation( const G4String& processName, 
                                                   >> 114                  const G4String& particleName, 
                                                   >> 115            G4bool          fActive );
                                                   >> 116   void SetProcessActivation( const G4String& processName, 
                                                   >> 117                  G4ParticleDefinition* particle, 
                                                   >> 118            G4bool          fActive );
                                                   >> 119   void SetProcessActivation( const G4String& processName, 
                                                   >> 120                  G4ProcessManager* processManager, 
                                                   >> 121            G4bool          fActive  );
                                                   >> 122   void SetProcessActivation( G4ProcessType   processType, 
                                                   >> 123            G4bool          fActive  );
                                                   >> 124   void SetProcessActivation( G4ProcessType   processType,
                                                   >> 125                  const G4String& particleName, 
                                                   >> 126            G4bool          fActive  );
                                                   >> 127   void SetProcessActivation( G4ProcessType   processType,
                                                   >> 128                  G4ParticleDefinition* particle, 
                                                   >> 129            G4bool          fActive );
                                                   >> 130   void SetProcessActivation( G4ProcessType   processType,
                                                   >> 131                  G4ProcessManager* processManager, 
                                                   >> 132            G4bool          fActive  );
                                                   >> 133   // These methods are provided to activate or inactivate processes
                                                   >> 134 
                                                   >> 135  public:
                                                   >> 136   typedef std::vector<G4ProcTblElement*>  G4ProcTableVector;
                                                   >> 137   typedef std::vector<G4String> G4ProcNameVector;
                                                   >> 138 
                                                   >> 139  public: // with description
                                                   >> 140   G4ProcNameVector*  GetNameList();
                                                   >> 141   // return pointer of the list of process name
157                                                   142 
158     static G4ThreadLocal G4ProcessTable* fProc << 143   G4ProcTableVector* GetProcTableVector();
159     G4ProcessTableMessenger* fProcTblMessenger << 144   // return pointer of the vector of G4ProcTblElement
                                                   >> 145   
                                                   >> 146  private:
                                                   >> 147   G4ProcTableVector* Find(  G4ProcTableVector* procTableVector,
                                                   >> 148           const G4String& processName );
                                                   >> 149   G4ProcTableVector* Find(  G4ProcTableVector* procTableVector,
                                                   >> 150           G4ProcessType   processType );
                                                   >> 151   // return pointer of a ProcTableVector 
                                                   >> 152   //  which includes ProcTbleElement specified
160                                                   153 
161     G4ProcTableVector* fProcTblVector = nullpt << 154   G4ProcessVector*   ExtractProcesses( G4ProcTableVector* procTableVector);
162     G4ProcNameVector* fProcNameVector = nullpt << 155   // extract all process objects from the process table 
                                                   >> 156  
                                                   >> 157  public: // with description
                                                   >> 158   void DumpInfo(G4VProcess* process, G4ParticleDefinition* particle=0);
                                                   >> 159   // dump out information of the process table
                                                   >> 160   //  second argument is used to specify processes designated by a particle 
                                                   >> 161     
                                                   >> 162  public: // with description
                                                   >> 163    void  SetVerboseLevel(G4int value);
                                                   >> 164    G4int GetVerboseLevel() const;
                                                   >> 165    // Set/Get controle flag for output message
                                                   >> 166    //  0: Silent
                                                   >> 167    //  1: Warning message
                                                   >> 168    //  2: More
                                                   >> 169 
                                                   >> 170 
                                                   >> 171  private:
                                                   >> 172   static G4ThreadLocal G4ProcessTable*    fProcessTable;
                                                   >> 173   G4ProcessTableMessenger*   fProcTblMessenger;
                                                   >> 174 
                                                   >> 175  private:
                                                   >> 176   G4ProcTableVector*        fProcTblVector;
                                                   >> 177   G4ProcNameVector*         fProcNameVector;
                                                   >> 178   // list of G4ProcTblElement
163                                                   179   
164     G4ProcTableVector* tmpTblVector = nullptr; << 180   G4ProcTableVector*        tmpTblVector;
165       // Used only internally as temporary buf << 181   // used only internaly for temporary buffer.
166                                                   182 
167     std::vector<G4VProcess*> fListProcesses;   << 183  private:
168       // Used for registration of process inst << 184    G4int verboseLevel;
                                                   >> 185    // controle flag for output message
169                                                   186 
170     G4int verboseLevel = 1;                    << 
171       // Control flag for output message       << 
172 };                                                187 };
173                                                   188 
174 #include "G4ProcessTable.icc"                     189 #include "G4ProcessTable.icc"
175                                                << 
176 #endif                                            190 #endif
177                                                   191