Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/management/include/G4IonTable.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 /particles/management/include/G4IonTable.hh (Version 11.3.0) and /particles/management/include/G4IonTable.hh (Version 2.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 // G4IonTable                                  <<   8 // $Id: G4IonTable.hh,v 1.15 2000/02/25 07:36:14 kurasige Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-02-00 $
 27 //                                                 10 //
 28 // Class description:                          <<  11 // 
                                                   >>  12 // ------------------------------------------------------------
                                                   >>  13 //  GEANT 4 class header file 
 29 //                                                 14 //
 30 // G4IonTable stores all pointers to G4Particl <<  15 //  For information related to this code contact:
                                                   >>  16 //  CERN, IT Division, ASD group
                                                   >>  17 //  History: first implementation, 
                                                   >>  18 //      based on object model of June 27, 98 H.Kurashige
                                                   >>  19 // ------------------------------------------------------------
                                                   >>  20 //      modified GetIon                 02 Aug., 98 H.Kurashige
                                                   >>  21 //      added Remove()                  06 Nov.,98 H.Kurashige
                                                   >>  22 //      add GetNucleusMass              15 Mar. 99  H.Kurashige
                                                   >>  23 //          -----
                                                   >>  24 //      Modified GetIon methods                  17 Aug. 99 H.Kurashige
                                                   >>  25 //      New design using G4VIsotopeTable          5 Oct. 99 H.Kurashige
 31                                                    26 
 32 // Author: H.Kurashige, 27 June 1998           <<  27 #ifndef G4IonTable_h
 33 // ------------------------------------------- <<  28 #define G4IonTable_h 1
 34 #ifndef G4IonTable_hh                          << 
 35 #define G4IonTable_hh 1                        << 
 36                                                    29 
 37 #include "G4Ions.hh"                           << 
 38 #include "G4ParticleDefinition.hh"             << 
 39 #include "G4ParticleTable.hh"                  << 
 40 #include "G4ios.hh"                                30 #include "G4ios.hh"
 41 #include "globals.hh"                              31 #include "globals.hh"
                                                   >>  32 #include "G4ParticleDefinition.hh"
 42                                                    33 
 43 #include <cmath>                               <<  34 #include "g4std/vector"
 44 #include <map>                                 << 
 45 #include <vector>                              << 
 46                                                    35 
 47 class G4ParticleTable;                             36 class G4ParticleTable;
 48 class G4VIsotopeTable;                         <<  37 class G4VIsotopeTable; 
 49 class G4IsotopeProperty;                           38 class G4IsotopeProperty;
 50 class G4NuclideTable;                          << 
 51                                                    39 
 52 class G4IonTable                                   40 class G4IonTable
 53 {                                                  41 {
 54   public:                                      <<  42  // Class Description
 55     using G4IonList = std::multimap<G4int, con <<  43  //   G4IonTable is the table of pointer to G4ParticleDefinition
 56     using G4IonListIterator = std::multimap<G4 <<  44  //   In G4IonTable, each G4ParticleDefinition pointer is stored
 57                                                <<  45  //
 58     // Constructor, destructor                 <<  46 
 59     G4IonTable();                              <<  47  public:
 60     ~G4IonTable();                             <<  48    // Use STL Vector as list of ions
 61                                                <<  49    typedef G4std::vector<G4ParticleDefinition*> G4IonList;
 62     // Forbidden copy constructor and assignme <<  50 
 63     G4IonTable(const G4IonTable&) = delete;    <<  51  public:
 64     G4IonTable& operator=(const G4IonTable&) = <<  52   // constructor
 65                                                <<  53    G4IonTable();
 66     static G4IonTable* GetIonTable();          <<  54 
 67                                                <<  55  protected:
 68     // Method is used by each worker thread to <<  56    // hide copy construictor as protected 
 69     // from the master thread.                 <<  57    G4IonTable(const  G4IonTable &right);
 70     void WorkerG4IonTable();                   <<  58 
 71                                                <<  59  public:
 72     // Destructor for worker                   <<  60   // destructor
 73     void DestroyWorkerG4IonTable();            <<  61    virtual ~G4IonTable();
 74                                                <<  62 
 75     // Get number of elements defined in the I <<  63  public: // With Description
 76     G4int GetNumberOfElements() const;         <<  64    // Register Isotope table
 77                                                <<  65    void RegisterIsotopeTable(G4VIsotopeTable* table);
 78     // Register Isotope table                  <<  66    G4VIsotopeTable* GetIsotopeTable() const;
 79     void RegisterIsotopeTable(G4VIsotopeTable* <<  67    // G4IonTable asks properties of isotopes to this G4VIsotopeTable 
 80                                                <<  68    // by using FindIsotope(G4IsotopeProperty* property) method.
 81     // G4IonTable asks properties of isotopes  <<  69    
 82     // by using FindIsotope(G4IsotopeProperty* <<  70    // ---------------------------  
 83     G4VIsotopeTable* GetIsotopeTable(std::size <<  71    // FindIon/GetIon
 84                                                <<  72    //   FindIon methods return pointer of ion if it exists       
 85     // All ground state ions are created.      <<  73    //   GetIon methods also return pointer of ion. In GetIon 
 86     // Stable ground states are defined in G4N <<  74    //   methods the designated ion will be created if it does not exist.
 87     void CreateAllIon();                       <<  75    //
 88                                                <<  76    // !! PDGCharge inG4ParticleDefinition of ions is           !!
 89     // All excited ions with long life time (> <<  77    // !! electric charge of nucleus (i.e. fully ionized ions)  !!
 90     // Isomers are defined in G4VIsotopeTable  <<  78    // -----------------------------
 91     void CreateAllIsomer();                    <<  79 
 92                                                <<  80    // Find/Get "ground state" 
 93     // All nuclide with a life time longer tha <<  81    G4ParticleDefinition* GetIon(G4int Z, G4int A, G4int J=0);
 94     // prior to the event loop                 <<  82    // The ion is assumed to be ground state (i.e Excited energy = 0) 
 95     void PrepareNuclideTable();                <<  83    //   Z: Atomic Number
 96     void PreloadNuclide();                     <<  84    //   A: Atomic Mass
 97                                                <<  85    //   J: Total Angular momentum (in unit of 1/2)
 98     // --------------------------------------- <<  86 
 99     // FindIon/GetIon                          <<  87    // Find/Get "excited state" 
100     //   FindIon() methods return pointer of i <<  88    G4ParticleDefinition* FindIon(G4int Z, G4int A, G4double E, G4int J=0);
101     //   GetIon() methods also return pointer  <<  89    G4ParticleDefinition* GetIon(G4int Z, G4int A, G4double E, G4int J=0);
102     //   ion is created if it does not exist.  <<  90    //   Z: Atomic Number
103     //                                         <<  91    //   A: Atomic Mass
104     // !! PDGCharge in G4ParticleDefinition of <<  92    //   J: Total Angular momentum (in unit of 1/2)
105     // !! electric charge of nucleus (i.e. ful <<  93    //   E: Excitaion energy
106     // --------------------------------------- <<  94 
107                                                <<  95    G4ParticleDefinition* GetIon(G4int Z, G4int A, G4int J, G4int Q);
108     // Find/Get "ground state" and "excited st <<  96    // This method is provided for compatibilties 
109     //                                         <<  97    // The third and last arguments gives no effect
110     G4ParticleDefinition* GetIon(G4int Z, G4in <<  98 
111     G4ParticleDefinition* GetIon(G4int Z, G4in <<  99    static G4bool        IsIon(G4ParticleDefinition*);
112     G4ParticleDefinition* GetIon(G4int Z, G4in << 100    // return true if the particle is ion
113     G4ParticleDefinition* GetIon(G4int Z, G4in << 101 
114                                  G4int J = 0); << 102    G4String             GetIonName(G4int Z, G4int A, G4double E) const;
115     G4ParticleDefinition* GetIon(G4int Z, G4in << 103    // get ion name
116     G4ParticleDefinition* GetIon(G4int Z, G4in << 104 
117     G4ParticleDefinition* GetIon(G4int Z, G4in << 105    G4double             GetIonMass(G4int Z, G4int A) const;
118                                  G4Ions::G4Flo << 106    G4double             GetNucleusMass(G4int Z, G4int A) const;
119     G4ParticleDefinition* GetIon(G4int Z, G4in << 107    // These two methods returns Nucleus (i.e. full ionized atom) mass 
120     // Z: Atomic Number                        << 108    // ,where Z is Atomic Number (number of protons) and
121     // A: Atomic Mass (nn + np +nlambda)       << 109    //  A is Atomic Number (number of nucleons)
122     // nL: Number of Lambda                    << 110 
123     // E: Excitation energy                    << 111   
124     // lvl:  Isomer Level 0: ground state)     << 112    G4int                 Entries() const;
125     // flb:  Floating level base (enum defined << 113    // Return number of ions in the table
126     // flbChar:  Floating level base denoted b << 114 
127     //           (<null>,X,Y,Z,U,V,W,R,S,T,A,B << 115    G4ParticleDefinition* GetParticle(G4int index) const;
128     // J: Total Angular momentum (in unit of 1 << 116    // Return the pointer of index-th ion in the table
129                                                << 117 
130     // The ion can be retrieved by using PDG e << 118    G4bool                Contains(const G4ParticleDefinition *particle) const;
131     // !! Only ground state can be obtained .i << 119    // Return 'true' if the ion exists
132     G4ParticleDefinition* GetIon(G4int encodin << 120 
133                                                << 121    void                  Insert(G4ParticleDefinition* particle);
134     // Find/Get "excited state"                << 122    void                  Remove(G4ParticleDefinition* particle);
135     //                                         << 123    // Insert/Remove an ion in the table
136     G4ParticleDefinition* FindIon(G4int Z, G4i << 124 
137     G4ParticleDefinition* FindIon(G4int Z, G4i << 125     void DumpTable(const G4String &particle_name = "ALL") const;
138     G4ParticleDefinition* FindIon(G4int Z, G4i << 126    // dump information of particles specified by name 
139     G4ParticleDefinition* FindIon(G4int Z, G4i << 127 
140                                   G4int J = 0) << 128 
141     G4ParticleDefinition* FindIon(G4int Z, G4i << 129  protected:
142     G4ParticleDefinition* FindIon(G4int Z, G4i << 130    G4ParticleDefinition* CreateIon(G4int Z, G4int A, G4double E, G4int J);
143     G4ParticleDefinition* FindIon(G4int Z, G4i << 131    // Create Ion 
144                                   G4Ions::G4Fl << 132    
145     G4ParticleDefinition* FindIon(G4int Z, G4i << 133    G4IsotopeProperty* FindIsotope(G4int Z, G4int A, G4double E, G4int J);
146                                   G4int J = 0) << 134    // Ask properties of isotopes to this G4VIsotopeTable 
147     // Z: Atomic Number                        << 135    
148     // A: Atomic Mass (nn + np +nlambda)       << 136    G4ParticleDefinition* GetLightIon(G4int Z, G4int A) const;
149     // nL: Number of Lambda                    << 137    
150     // E: Excitaion energy                     << 138    
151     // lvl:  Isomer Level 0: ground state)     << 139    G4bool                IsLightIon(G4ParticleDefinition*) const;
152     // flb:  Floating level base (enum defined << 140    // return true if the particle is pre-defined ion
153     // flbChar:  Floating level base denoted b << 141  
154     //           (<null>,X,Y,Z,U,V,W,R,S,T,A,B << 142    void                  AddProcessManager(const G4String& ionName);
155     // J: Total Angular momentum (in unit of 1 << 143    // Add process manager to ions with name of 'ionName'
156                                                << 144 
157     // Return true if the particle is ion      << 145    void                  SetCuts(G4ParticleDefinition* ion);
158     static G4bool IsIon(const G4ParticleDefini << 146    // Set cut value same as "GenericIon" and build physics tables
159                                                << 147 
160     // Return true if the particle is anti_ion << 148    G4int                GetVerboseLevel() const;
161     static G4bool IsAntiIon(const G4ParticleDe << 149    // get Verbose Level defined in G4ParticleTable
162                                                << 150 
163     // Get ion name                            << 151  private:
164     G4String GetIonName(G4int Z, G4int A, G4in << 152    G4IonList*                  fIonList; 
165     G4String GetIonName(G4int Z, G4int A, G4do << 153 
166                         G4Ions::G4FloatLevelBa << 154    G4VIsotopeTable*            fIsotopeTable;
167     G4String GetIonName(G4int Z, G4int A, G4in << 155  
168                         G4Ions::G4FloatLevelBa << 156    enum { numberOfElements = 110};
169     G4String GetIonName(G4int Z, G4int A, G4in << 157    static const G4String       elementName[numberOfElements];
170                                                << 158 
171     // Get PDG code for Ions.                  << 159 };
172     // Nuclear codes are given as 10-digit num << 160 
173     // For a nucleus consisting of np protons  << 161 inline G4bool  G4IonTable::Contains(const G4ParticleDefinition* particle) const
174     // A = np + nn and Z = np.                 << 162 {
175     // I gives the isomer level, with I = 0 co << 163   G4IonList::iterator i;
176     // to the ground state and I >0 to excitat << 164   for (i = fIonList->begin(); i!= fIonList->end(); ++i) {
177     static G4int GetNucleusEncoding(G4int Z, G << 165     if (**i==*particle) return true;
178                                                << 166   }
179     // Get PDG code for Hyper-Nucleus Ions.    << 167   return false;
180     // Nuclear codes are given as 10-digit num << 168 }
181     // For a nucleus consisting of np protons  << 169 
182     // A = np + nn +nlambda and Z = np.        << 170 inline G4int G4IonTable::Entries() const
183     // nL = nlambda                            << 171 {
184     // I gives the isomer level, with I = 0 co << 172   return fIonList->size();
185     // to the ground state and I >0 to excitat << 173 }
186     static G4int GetNucleusEncoding(G4int Z, G << 174 
187                                                << 175 inline G4ParticleDefinition*  G4IonTable::GetParticle(G4int index) const
188     static G4bool GetNucleusByEncoding(G4int e << 176 {
189     static G4bool GetNucleusByEncoding(G4int e << 177   if ( (index >=0 ) && (index < Entries()) ){
190                                        G4int&  << 178     return (*fIonList)[index];
191     // Energy will not be given even for excit << 179   } else {
192                                                << 180     return 0; 
193     // These methods returns Nucleus (i.e. ful << 181   } 
194     //  Z is Atomic Number (number of protons) << 182 }
195     //  A is Atomic Number (number of nucleons << 183 
196     //  nL is number of lambda (A= nn + np + n << 
197     //  lvl is isomer level                    << 
198     G4double GetIonMass(G4int Z, G4int A, G4in << 
199     G4double GetNucleusMass(G4int Z, G4int A,  << 
200     G4double GetIsomerMass(G4int Z, G4int A, G << 
201                                                << 
202     // Returns a life time of an ion. -1 for s << 
203     // that is not listed in G4NuclideTable    << 
204     G4double GetLifeTime(const G4ParticleDefin << 
205     G4double GetLifeTime(G4int Z, G4int A, G4d << 
206                          G4Ions::G4FloatLevelB << 
207     G4double GetLifeTime(G4int Z, G4int A, G4d << 
208                                                << 
209     G4ParticleDefinition* GetMuonicAtom(G4Ions << 
210     G4ParticleDefinition* GetMuonicAtom(G4int  << 
211                                                << 
212     // Return number of ions in the table      << 
213     G4int Entries() const;                     << 
214                                                << 
215     // Return the pointer of index-th ion in t << 
216     G4ParticleDefinition* GetParticle(G4int in << 
217                                                << 
218     // Return 'true' if the ion exists         << 
219     G4bool Contains(const G4ParticleDefinition << 
220                                                << 
221     // Insert/Remove an ion in the table       << 
222     void Insert(const G4ParticleDefinition* pa << 
223     void Remove(const G4ParticleDefinition* pa << 
224                                                << 
225     // Erase all contents in the list (not del << 
226     void clear();                              << 
227                                                << 
228     // Return number of ions in the table      << 
229     G4int size() const;                        << 
230                                                << 
231     // Dump information of particles specified << 
232     void DumpTable(const G4String& particle_na << 
233                                                << 
234   public:                                      << 
235     // Needed for MT                           << 
236     void InitializeLightIons();                << 
237                                                << 
238     // It is very important for multithreaded  << 
239     // the particle table pointer and the ion  << 
240     // to let each worker thread hold its own  << 
241     // and the ion list. This implementation i << 
242     // table thread private. The two shadow po << 
243     // thread to copy the content from the mas << 
244     static G4ThreadLocal G4IonList* fIonList;  << 
245     static G4ThreadLocal std::vector<G4VIsotop << 
246     static G4IonList* fIonListShadow;          << 
247     static std::vector<G4VIsotopeTable*>* fIso << 
248                                                << 
249     enum                                       << 
250     {                                          << 
251       numberOfElements = 118                   << 
252     };                                         << 
253     static const G4String elementName[numberOf << 
254                                                   184 
255 #ifdef G4MULTITHREADED                         << 
256     static G4Mutex ionTableMutex;              << 
257 #endif                                            185 #endif
258                                                   186 
259   protected:                                   << 
260     G4ParticleDefinition* FindIonInMaster(G4in << 
261     G4ParticleDefinition* FindIonInMaster(G4in << 
262     G4ParticleDefinition* FindIonInMaster(G4in << 
263                                           G4Io << 
264     G4ParticleDefinition* FindIonInMaster(G4in << 
265                                           G4Io << 
266                                                << 
267     G4ParticleDefinition* CreateIon(G4int Z, G << 
268     G4ParticleDefinition* CreateIon(G4int Z, G << 
269                                     G4Ions::G4 << 
270     G4ParticleDefinition* CreateIon(G4int Z, G << 
271     G4ParticleDefinition* CreateIon(G4int Z, G << 
272                                                << 
273     void InsertWorker(const G4ParticleDefiniti << 
274                                                << 
275     // Create Ion                              << 
276                                                << 
277     G4IsotopeProperty* FindIsotope(G4int Z, G4 << 
278                                    G4Ions::G4F << 
279     G4IsotopeProperty* FindIsotope(G4int Z, G4 << 
280     // Ask properties of isotopes              << 
281                                                << 
282     G4ParticleDefinition* GetLightIon(G4int Z, << 
283     G4ParticleDefinition* GetLightAntiIon(G4in << 
284                                                << 
285     // Return true if the particle is pre-defi << 
286     G4bool IsLightIon(const G4ParticleDefiniti << 
287     G4bool IsLightAntiIon(const G4ParticleDefi << 
288                                                << 
289     // Add process manager to ions with name o << 
290     void AddProcessManager(G4ParticleDefinitio << 
291                                                   187 
292     // Get Verbose Level defined in G4Particle << 
293     G4int GetVerboseLevel() const;             << 
294                                                   188 
295   private:                                     << 
296     G4NuclideTable* pNuclideTable = nullptr;   << 
297                                                   189 
298     // Isomer table and flag of creation       << 
299     G4bool isIsomerCreated = false;            << 
300 };                                             << 
301                                                   190 
302 // ------------------------                    << 
303 // Inline methods                              << 
304 // ------------------------                    << 
305                                                   191 
306 inline G4int G4IonTable::GetNumberOfElements() << 
307 {                                              << 
308   return numberOfElements;                     << 
309 }                                              << 
310                                                   192 
311 #endif                                         << 193 
                                                   >> 194 
                                                   >> 195 
312                                                   196