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


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4IonTable                                  << 
 27 //                                                 23 //
 28 // Class description:                          <<  24 // $Id: G4IonTable.hh,v 1.21 2004/12/02 08:08:58 kurasige Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-08-00 $
 29 //                                                 26 //
 30 // G4IonTable stores all pointers to G4Particl <<  27 // 
                                                   >>  28 // ------------------------------------------------------------
                                                   >>  29 //  GEANT 4 class header file 
                                                   >>  30 //
                                                   >>  31 //  History: first implementation, 
                                                   >>  32 //      based on object model of June 27, 98 H.Kurashige
                                                   >>  33 // ------------------------------------------------------------
                                                   >>  34 //      modified GetIon                 02 Aug., 98 H.Kurashige
                                                   >>  35 //      added Remove()                  06 Nov.,98 H.Kurashige
                                                   >>  36 //      add GetNucleusMass              15 Mar. 99  H.Kurashige
                                                   >>  37 //          -----
                                                   >>  38 //      Modified GetIon methods                  17 Aug. 99 H.Kurashige
                                                   >>  39 //      New design using G4VIsotopeTable          5 Oct. 99 H.Kurashige
 31                                                    40 
 32 // Author: H.Kurashige, 27 June 1998           <<  41 #ifndef G4IonTable_h
 33 // ------------------------------------------- <<  42 #define G4IonTable_h 1
 34 #ifndef G4IonTable_hh                          << 
 35 #define G4IonTable_hh 1                        << 
 36                                                    43 
 37 #include "G4Ions.hh"                           << 
 38 #include "G4ParticleDefinition.hh"             << 
 39 #include "G4ParticleTable.hh"                  << 
 40 #include "G4ios.hh"                                44 #include "G4ios.hh"
 41 #include "globals.hh"                              45 #include "globals.hh"
                                                   >>  46 #include "G4ParticleDefinition.hh"
 42                                                    47 
 43 #include <cmath>                                   48 #include <cmath>
 44 #include <map>                                 << 
 45 #include <vector>                                  49 #include <vector>
 46                                                    50 
 47 class G4ParticleTable;                             51 class G4ParticleTable;
 48 class G4VIsotopeTable;                         <<  52 class G4VIsotopeTable; 
 49 class G4IsotopeProperty;                           53 class G4IsotopeProperty;
 50 class G4NuclideTable;                          << 
 51                                                    54 
 52 class G4IonTable                                   55 class G4IonTable
 53 {                                                  56 {
 54   public:                                      <<  57  // Class Description
 55     using G4IonList = std::multimap<G4int, con <<  58  //   G4IonTable is the table of pointer to G4ParticleDefinition
 56     using G4IonListIterator = std::multimap<G4 <<  59  //   In G4IonTable, each G4ParticleDefinition pointer is stored
 57                                                <<  60  //
 58     // Constructor, destructor                 <<  61 
 59     G4IonTable();                              <<  62  public:
 60     ~G4IonTable();                             <<  63    // Use STL Vector as list of ions
 61                                                <<  64    typedef std::vector<G4ParticleDefinition*> G4IonList;
 62     // Forbidden copy constructor and assignme <<  65 
 63     G4IonTable(const G4IonTable&) = delete;    <<  66  public:
 64     G4IonTable& operator=(const G4IonTable&) = <<  67   // constructor
 65                                                <<  68    G4IonTable();
 66     static G4IonTable* GetIonTable();          <<  69 
 67                                                <<  70  protected:
 68     // Method is used by each worker thread to <<  71    // hide copy construictor as protected 
 69     // from the master thread.                 <<  72    G4IonTable(const  G4IonTable &right);
 70     void WorkerG4IonTable();                   <<  73    G4IonTable & operator = (const G4IonTable &) {return *this;}
 71                                                <<  74 
 72     // Destructor for worker                   <<  75  public:
 73     void DestroyWorkerG4IonTable();            <<  76   // destructor
 74                                                <<  77    virtual ~G4IonTable();
 75     // Get number of elements defined in the I <<  78 
 76     G4int GetNumberOfElements() const;         <<  79  public: // With Description
 77                                                <<  80    G4int GetNumberOfElements() const;
 78     // Register Isotope table                  <<  81    // Get number of elements defined in the IonTable
 79     void RegisterIsotopeTable(G4VIsotopeTable* <<  82 
 80                                                <<  83    // Register Isotope table
 81     // G4IonTable asks properties of isotopes  <<  84    void RegisterIsotopeTable(G4VIsotopeTable* table);
 82     // by using FindIsotope(G4IsotopeProperty* <<  85    G4VIsotopeTable* GetIsotopeTable() const;
 83     G4VIsotopeTable* GetIsotopeTable(std::size <<  86    // G4IonTable asks properties of isotopes to this G4VIsotopeTable 
 84                                                <<  87    // by using FindIsotope(G4IsotopeProperty* property) method.
 85     // All ground state ions are created.      <<  88    
 86     // Stable ground states are defined in G4N <<  89    // ---------------------------  
 87     void CreateAllIon();                       <<  90    // FindIon/GetIon
 88                                                <<  91    //   FindIon methods return pointer of ion if it exists       
 89     // All excited ions with long life time (> <<  92    //   GetIon methods also return pointer of ion. In GetIon 
 90     // Isomers are defined in G4VIsotopeTable  <<  93    //   methods the designated ion will be created if it does not exist.
 91     void CreateAllIsomer();                    <<  94    //
 92                                                <<  95    // !! PDGCharge inG4ParticleDefinition of ions is           !!
 93     // All nuclide with a life time longer tha <<  96    // !! electric charge of nucleus (i.e. fully ionized ions)  !!
 94     // prior to the event loop                 <<  97    // -----------------------------
 95     void PrepareNuclideTable();                <<  98 
 96     void PreloadNuclide();                     <<  99    // Find/Get "ground state" 
 97                                                << 100    G4ParticleDefinition* GetIon(G4int Z, G4int A, G4int J=0);
 98     // --------------------------------------- << 101    // The ion is assumed to be ground state (i.e Excited energy = 0) 
 99     // FindIon/GetIon                          << 102    //   Z: Atomic Number
100     //   FindIon() methods return pointer of i << 103    //   A: Atomic Mass
101     //   GetIon() methods also return pointer  << 104    //   J: Total Angular momentum (in unit of 1/2)
102     //   ion is created if it does not exist.  << 105 
103     //                                         << 106    // Find/Get "excited state" 
104     // !! PDGCharge in G4ParticleDefinition of << 107    G4ParticleDefinition* FindIon(G4int Z, G4int A, G4double E, G4int J=0);
105     // !! electric charge of nucleus (i.e. ful << 108    G4ParticleDefinition* GetIon(G4int Z, G4int A, G4double E, G4int J=0);
106     // --------------------------------------- << 109    //   Z: Atomic Number
107                                                << 110    //   A: Atomic Mass
108     // Find/Get "ground state" and "excited st << 111    //   J: Total Angular momentum (in unit of 1/2)
109     //                                         << 112    //   E: Excitaion energy
110     G4ParticleDefinition* GetIon(G4int Z, G4in << 113 
111     G4ParticleDefinition* GetIon(G4int Z, G4in << 114    G4ParticleDefinition* GetIon(G4int Z, G4int A, G4int J, G4int Q);
112     G4ParticleDefinition* GetIon(G4int Z, G4in << 115    // This method is provided for compatibilties 
113     G4ParticleDefinition* GetIon(G4int Z, G4in << 116    // The third and last arguments gives no effect
114                                  G4int J = 0); << 117 
115     G4ParticleDefinition* GetIon(G4int Z, G4in << 118    static G4bool        IsIon(G4ParticleDefinition*);
116     G4ParticleDefinition* GetIon(G4int Z, G4in << 119    // return true if the particle is ion
117     G4ParticleDefinition* GetIon(G4int Z, G4in << 120 
118                                  G4Ions::G4Flo << 121    G4String             GetIonName(G4int Z, G4int A, G4double E) const;
119     G4ParticleDefinition* GetIon(G4int Z, G4in << 122    // get ion name
120     // Z: Atomic Number                        << 123 
121     // A: Atomic Mass (nn + np +nlambda)       << 124    G4double             GetIonMass(G4int Z, G4int A) const;
122     // nL: Number of Lambda                    << 125    G4double             GetNucleusMass(G4int Z, G4int A) const;
123     // E: Excitation energy                    << 126    // These two methods returns Nucleus (i.e. full ionized atom) mass 
124     // lvl:  Isomer Level 0: ground state)     << 127    // ,where Z is Atomic Number (number of protons) and
125     // flb:  Floating level base (enum defined << 128    //  A is Atomic Number (number of nucleons)
126     // flbChar:  Floating level base denoted b << 129 
127     //           (<null>,X,Y,Z,U,V,W,R,S,T,A,B << 130   
128     // J: Total Angular momentum (in unit of 1 << 131    G4int                 Entries() const;
129                                                << 132    // Return number of ions in the table
130     // The ion can be retrieved by using PDG e << 133 
131     // !! Only ground state can be obtained .i << 134    G4ParticleDefinition* GetParticle(G4int index) const;
132     G4ParticleDefinition* GetIon(G4int encodin << 135    // Return the pointer of index-th ion in the table
133                                                << 136 
134     // Find/Get "excited state"                << 137    G4bool                Contains(const G4ParticleDefinition *particle) const;
135     //                                         << 138    // Return 'true' if the ion exists
136     G4ParticleDefinition* FindIon(G4int Z, G4i << 139 
137     G4ParticleDefinition* FindIon(G4int Z, G4i << 140    void                  Insert(G4ParticleDefinition* particle);
138     G4ParticleDefinition* FindIon(G4int Z, G4i << 141    void                  Remove(G4ParticleDefinition* particle);
139     G4ParticleDefinition* FindIon(G4int Z, G4i << 142    // Insert/Remove an ion in the table
140                                   G4int J = 0) << 143 
141     G4ParticleDefinition* FindIon(G4int Z, G4i << 144     void DumpTable(const G4String &particle_name = "ALL") const;
142     G4ParticleDefinition* FindIon(G4int Z, G4i << 145    // dump information of particles specified by name 
143     G4ParticleDefinition* FindIon(G4int Z, G4i << 146 
144                                   G4Ions::G4Fl << 147 
145     G4ParticleDefinition* FindIon(G4int Z, G4i << 148  protected:
146                                   G4int J = 0) << 149    G4ParticleDefinition* CreateIon(G4int Z, G4int A, G4double E, G4int J);
147     // Z: Atomic Number                        << 150    // Create Ion 
148     // A: Atomic Mass (nn + np +nlambda)       << 151    
149     // nL: Number of Lambda                    << 152    G4IsotopeProperty* FindIsotope(G4int Z, G4int A, G4double E, G4int J);
150     // E: Excitaion energy                     << 153    // Ask properties of isotopes to this G4VIsotopeTable 
151     // lvl:  Isomer Level 0: ground state)     << 154    
152     // flb:  Floating level base (enum defined << 155    G4ParticleDefinition* GetLightIon(G4int Z, G4int A) const;
153     // flbChar:  Floating level base denoted b << 156    
154     //           (<null>,X,Y,Z,U,V,W,R,S,T,A,B << 157    
155     // J: Total Angular momentum (in unit of 1 << 158    G4bool                IsLightIon(G4ParticleDefinition*) const;
156                                                << 159    // return true if the particle is pre-defined ion
157     // Return true if the particle is ion      << 160  
158     static G4bool IsIon(const G4ParticleDefini << 161    void                  AddProcessManager(const G4String& ionName);
159                                                << 162    // Add process manager to ions with name of 'ionName'
160     // Return true if the particle is anti_ion << 163 
161     static G4bool IsAntiIon(const G4ParticleDe << 164    G4int                GetVerboseLevel() const;
162                                                << 165    // get Verbose Level defined in G4ParticleTable
163     // Get ion name                            << 166 
164     G4String GetIonName(G4int Z, G4int A, G4in << 167  private:
165     G4String GetIonName(G4int Z, G4int A, G4do << 168    G4IonList*                  fIonList; 
166                         G4Ions::G4FloatLevelBa << 169 
167     G4String GetIonName(G4int Z, G4int A, G4in << 170    G4VIsotopeTable*            fIsotopeTable;
168                         G4Ions::G4FloatLevelBa << 171  
169     G4String GetIonName(G4int Z, G4int A, G4in << 172    enum { numberOfElements = 110};
170                                                << 173    static const G4String       elementName[numberOfElements];
171     // Get PDG code for Ions.                  << 174 
172     // Nuclear codes are given as 10-digit num << 175 };
173     // For a nucleus consisting of np protons  << 176 
174     // A = np + nn and Z = np.                 << 177 inline G4int  G4IonTable::GetNumberOfElements() const
175     // I gives the isomer level, with I = 0 co << 178 {
176     // to the ground state and I >0 to excitat << 179   return numberOfElements;
177     static G4int GetNucleusEncoding(G4int Z, G << 180 }
178                                                << 181 inline G4bool  G4IonTable::Contains(const G4ParticleDefinition* particle) const
179     // Get PDG code for Hyper-Nucleus Ions.    << 182 {
180     // Nuclear codes are given as 10-digit num << 183   G4IonList::iterator i;
181     // For a nucleus consisting of np protons  << 184   for (i = fIonList->begin(); i!= fIonList->end(); ++i) {
182     // A = np + nn +nlambda and Z = np.        << 185     if (**i==*particle) return true;
183     // nL = nlambda                            << 186   }
184     // I gives the isomer level, with I = 0 co << 187   return false;
185     // to the ground state and I >0 to excitat << 188 }
186     static G4int GetNucleusEncoding(G4int Z, G << 189 
187                                                << 190 inline G4int G4IonTable::Entries() const
188     static G4bool GetNucleusByEncoding(G4int e << 191 {
189     static G4bool GetNucleusByEncoding(G4int e << 192   return fIonList->size();
190                                        G4int&  << 193 }
191     // Energy will not be given even for excit << 194 
192                                                << 195 inline G4ParticleDefinition*  G4IonTable::GetParticle(G4int index) const
193     // These methods returns Nucleus (i.e. ful << 196 {
194     //  Z is Atomic Number (number of protons) << 197   if ( (index >=0 ) && (index < Entries()) ){
195     //  A is Atomic Number (number of nucleons << 198     return (*fIonList)[index];
196     //  nL is number of lambda (A= nn + np + n << 199   } else {
197     //  lvl is isomer level                    << 200     return 0; 
198     G4double GetIonMass(G4int Z, G4int A, G4in << 201   } 
199     G4double GetNucleusMass(G4int Z, G4int A,  << 202 }
200     G4double GetIsomerMass(G4int Z, G4int A, G << 203 
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                                                   204 
255 #ifdef G4MULTITHREADED                         << 
256     static G4Mutex ionTableMutex;              << 
257 #endif                                            205 #endif
258                                                   206 
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                                                   207 
292     // Get Verbose Level defined in G4Particle << 
293     G4int GetVerboseLevel() const;             << 
294                                                   208 
295   private:                                     << 
296     G4NuclideTable* pNuclideTable = nullptr;   << 
297                                                   209 
298     // Isomer table and flag of creation       << 
299     G4bool isIsomerCreated = false;            << 
300 };                                             << 
301                                                   210 
302 // ------------------------                    << 
303 // Inline methods                              << 
304 // ------------------------                    << 
305                                                   211 
306 inline G4int G4IonTable::GetNumberOfElements() << 
307 {                                              << 
308   return numberOfElements;                     << 
309 }                                              << 
310                                                   212 
311 #endif                                         << 213 
                                                   >> 214 
                                                   >> 215 
312                                                   216