Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/management/include/G4ParticleDefinition.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/G4ParticleDefinition.hh (Version 11.3.0) and /particles/management/include/G4ParticleDefinition.hh (Version 3.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 // G4ParticleDefinition                        <<   8 // $Id: G4ParticleDefinition.hh,v 1.7 2000/02/25 07:36:15 kurasige Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-03-00 $
 27 //                                                 10 //
 28 // Class description:                          <<  11 // 
                                                   >>  12 // ------------------------------------------------------------
                                                   >>  13 //  GEANT 4 class header file 
 29 //                                                 14 //
 30 // This class contains all the static data of  <<  15 //  For information related to this code contact:
 31 // It uses the process manager in order to col <<  16 //  CERN, CN Division, ASD group
 32 // this kind of particle can undertake.        <<  17 //  History: first implementation, based on object model of
 33                                                <<  18 //  2nd December 1995, G.Cosmo
 34 // Authors: G.Cosmo, 2 December 1995 - Design, <<  19 // ---------------- G4ParticleDefinition ----------------
 35 //          M.Asai, 29 January 1996 - First im <<  20 // first implementation by Makoto Asai, 29 January 1996
 36 // History:                                    <<  21 // revised by G.Cosmo, 29 February 1996
 37 // - 1996-2003, H.Kurashige - Revisions        <<  22 // revised by H.Kurashige, 19 April 1996
 38 // - 11.03.2003, H.Kurashige - Restructuring f <<  23 // revised by H.Kurashige, 4 July 1996
 39 // - 25.01.2013, G.Cosmo, A.Dotti - Introduced <<  24 // added GetEnergyCuts() and GetLengthCuts() by G.Cosmo, 11 July 1996
 40 // - 15.06.2017, K.L.Genser - Added support fo <<  25 // added Set/GetVerboseLevel()    H.Kurashige 11 Nov. 1997
 41 // ------------------------------------------- <<  26 // added SetCuts() and ResetCuts  H.Kurashige 15 Nov.1996
 42 #ifndef G4ParticleDefinition_hh                <<  27 // change SetProcessManager as public H.Kurashige 06 June 1998
 43 #define G4ParticleDefinition_hh 1              <<  28 // added  GetEnergyThreshold  H.Kurashige 08 June 1998
                                                   >>  29 // added  ShortLived flag and ApplyCuts flag  H.Kurashige 27  June 1998
                                                   >>  30 // fixed  some improper codings   H.Kurashige 08 Apr. 1999
                                                   >>  31 // added  sub-type  H.Kurashige 15 Feb. 2000
                                                   >>  32 // ------------------------------------------------------------
 44                                                    33 
 45 #include "G4PDefManager.hh"                    <<  34 #ifndef G4ParticleDefinition_h
 46 #include "G4ios.hh"                            <<  35 #define G4ParticleDefinition_h 1
 47 #include "globals.hh"                          << 
 48                                                    36 
 49 #include <CLHEP/Units/PhysicalConstants.h>     <<  37 #include "globals.hh"
 50                                                <<  38 #include "G4ios.hh"
 51 #include <vector>                              << 
 52                                                    39 
 53 class G4ProcessManager;                            40 class G4ProcessManager;
 54 class G4DecayTable;                                41 class G4DecayTable;
 55 class G4ParticleTable;                             42 class G4ParticleTable;
 56 class G4ParticlePropertyTable;                 <<  43 class G4Material;
 57 class G4VTrackingManager;                      << 
 58                                                << 
 59 using G4ParticleDefinitionSubInstanceManager = << 
 60                                                    44 
 61 class G4ParticleDefinition                     <<  45 class G4ParticleDefinition 
 62 {                                                  46 {
 63     friend class G4ParticlePropertyTable;      <<  47   // Class Description
                                                   >>  48   //  This class containes all the static data of a particle.
                                                   >>  49   //  It also has uses a process manager in order to collect
                                                   >>  50   //  all the processes this kind of particle can undertake.
                                                   >>  51   //
                                                   >>  52 
                                                   >>  53  public: // With Description
                                                   >>  54   //  Only one type of constructor can be used for G4ParticleDefinition.
                                                   >>  55   //  If you want to create new particle, you must set name of the particle 
                                                   >>  56   //  at construction. Most of members seen as arguments of the constructor 
                                                   >>  57   //  (except last 3 arguments concerning with decay ) are  "constant" 
                                                   >>  58   //  and can not be changed later. (No "SET" methods are available)
                                                   >>  59   //  Each type of particle must be constructed as a unique static object
                                                   >>  60   //  of special class derived from G4ParticleDefinition.
                                                   >>  61   //  see G4ParticleTypes for detail 
                                                   >>  62  
                                                   >>  63       G4ParticleDefinition(const G4String&  aName,  
                                                   >>  64                            G4double         mass,     
                                                   >>  65          G4double         width,
                                                   >>  66                            G4double         charge,   
                                                   >>  67          G4int            iSpin,
                                                   >>  68                            G4int            iParity,
                                                   >>  69          G4int            iConjugation,
                                                   >>  70                            G4int            iIsospin,   
                                                   >>  71          G4int            iIsospinZ, 
                                                   >>  72          G4int            gParity,
                                                   >>  73          const G4String&  pType,
                                                   >>  74                            G4int            lepton,
                                                   >>  75          G4int            baryon,
                                                   >>  76          G4int            encoding,
                                                   >>  77          G4bool           stable,
                                                   >>  78          G4double         lifetime,
                                                   >>  79          G4DecayTable     *decaytable,
                                                   >>  80          G4bool           shortlived = false);
                                                   >>  81 
                                                   >>  82        virtual ~G4ParticleDefinition();
                                                   >>  83       
                                                   >>  84   public: // With Description
                                                   >>  85       // These methods concerning cut values are provided 
                                                   >>  86       // to invoke corresponding methods for each particle type.
                                                   >>  87       // Actual implementation can be seen in the class 
                                                   >>  88       // G4ParticleWithCuts  
                                                   >>  89       virtual void          ResetCuts();
                                                   >>  90       virtual void          SetCuts(G4double );
                                                   >>  91       virtual void          ReCalcCuts();
                                                   >>  92       virtual G4double        GetLengthCuts() const;
                                                   >>  93       virtual G4double*         GetEnergyCuts() const;
                                                   >>  94       virtual G4double        GetEnergyThreshold(const G4Material* ) const;
                                                   >>  95  
                                                   >>  96       // applyCuts flag
                                                   >>  97       G4bool                GetApplyCutsFlag() const;
                                                   >>  98       void                  SetApplyCutsFlag(G4bool flag);
                                                   >>  99       
                                                   >> 100   public: // With Description
                                                   >> 101   // By these following Getxxxx methods, you can get values 
                                                   >> 102   // for members which can not be changed
                                                   >> 103   //  
                                                   >> 104       const G4String& GetParticleName() const { return theParticleName; }
                                                   >> 105 
                                                   >> 106       G4double GetPDGMass() const { return thePDGMass; }
                                                   >> 107       G4double GetPDGWidth() const { return thePDGWidth; } 
                                                   >> 108       G4double GetPDGCharge() const { return thePDGCharge; }
                                                   >> 109 
                                                   >> 110       G4double GetPDGSpin() const { return thePDGSpin; }
                                                   >> 111       G4int    GetPDGiSpin() const { return thePDGiSpin; }
                                                   >> 112       G4int    GetPDGiParity() const { return thePDGiParity; }
                                                   >> 113       G4int    GetPDGiConjugation() const { return thePDGiConjugation; }
                                                   >> 114       G4double GetPDGIsospin() const { return thePDGiIsospin; }
                                                   >> 115       G4double GetPDGIsospin3() const { return thePDGiIsospin3; }
                                                   >> 116       G4int    GetPDGiIsospin() const { return thePDGiIsospin; }
                                                   >> 117       G4int    GetPDGiIsospin3() const { return thePDGiIsospin3; }
                                                   >> 118       G4int    GetPDGiGParity() const { return thePDGiGParity; }
                                                   >> 119 
                                                   >> 120       const G4String& GetParticleType() const { return theParticleType; }
                                                   >> 121       const G4String& GetParticleSubType() const { return theParticleSubType; }
                                                   >> 122       G4int    GetLeptonNumber() const { return theLeptonNumber; }
                                                   >> 123       G4int    GetBaryonNumber() const { return theBaryonNumber; }
                                                   >> 124 
                                                   >> 125       G4int    GetPDGEncoding() const { return thePDGEncoding; }
                                                   >> 126       G4int    GetAntiPDGEncoding() const { return theAntiPDGEncoding; }
                                                   >> 127       void     SetAntiPDGEncoding(G4int aEncoding);
                                                   >> 128 
                                                   >> 129  
                                                   >> 130       G4int    GetQuarkContent(G4int flavor) const;
                                                   >> 131       G4int    GetAntiQuarkContent(G4int flavor) const;
                                                   >> 132       //  return the number of quark with flavor contained in this particle. 
                                                   >> 133       //  The value of flavor is assigned as follows 
                                                   >> 134       // 1:d, 2:u, 3:s, 4:c, 5:b, 6:t, 7:l(down type quark) 8:h(up type quark) 
                                                   >> 135  
                                                   >> 136   public: // With Description
                                                   >> 137       // ShortLived flag
                                                   >> 138       G4bool   IsShortLived() const { return fShortLivedFlag; }
                                                   >> 139 
                                                   >> 140       G4bool   GetPDGStable() const { return thePDGStable; }
                                                   >> 141       void     SetPDGStable(const G4bool aFlag) { thePDGStable=aFlag; }
                                                   >> 142 
                                                   >> 143       G4double GetPDGLifeTime() const { return thePDGLifeTime; }
                                                   >> 144       void     SetPDGLifeTime(G4double aLifeTime) { thePDGLifeTime = aLifeTime; }
                                                   >> 145 
                                                   >> 146   public:// With Description
                                                   >> 147       G4DecayTable* GetDecayTable();
                                                   >> 148       void          SetDecayTable(G4DecayTable* aDecayTable); 
                                                   >> 149       // Set/Get Decay Table
                                                   >> 150       //   !! Decay Table can be modified !!  
                                                   >> 151 
                                                   >> 152   public: // With Description
                                                   >> 153       G4ProcessManager* GetProcessManager() const; 
                                                   >> 154       void SetProcessManager(G4ProcessManager* aProcessManager); 
                                                   >> 155       // Set/Get Process Manager
                                                   >> 156       //   !! Process Manager can be modified !!  
 64                                                   157 
 65   public:                                      << 158       G4ParticleTable* GetParticleTable();
 66     // Only one type of constructor can be use << 159       // get pointer to the particle table
 67     // If you want to create new particle, you << 160 
 68     // at construction. Most of members seen a << 161       void DumpTable() const;
 69     // (except last 3 arguments concerning wit << 162       //  Prints information of data members.
 70     // and can not be changed later. (No "SET" << 
 71     // Each type of particle must be construct << 
 72     // of special class derived from G4Particl << 
 73     // See G4ParticleTypes for detail          << 
 74     // clang-format off                        << 
 75     G4ParticleDefinition(const G4String& aName << 
 76                          G4int iSpin, G4int iP << 
 77                          G4int iIsospinZ, G4in << 
 78                          G4int baryon, G4int e << 
 79                          G4DecayTable* decayta << 
 80                          const G4String& subTy << 
 81                          G4double magneticMome << 
 82     // clang-format on                         << 
 83                                                << 
 84     virtual ~G4ParticleDefinition();           << 
 85                                                << 
 86     // Can not use "copy constructor", equalit << 
 87     G4ParticleDefinition(const G4ParticleDefin << 
 88     G4ParticleDefinition& operator=(const G4Pa << 
 89                                                << 
 90     G4bool operator==(const G4ParticleDefiniti << 
 91     G4bool operator!=(const G4ParticleDefiniti << 
 92                                                << 
 93     // With the following Getxxxx methods, one << 
 94     // for members which can not be changed    << 
 95                                                << 
 96     const G4String& GetParticleName() const {  << 
 97                                                << 
 98     G4double GetPDGMass() const { return thePD << 
 99     G4double GetPDGWidth() const { return theP << 
100     G4double GetPDGCharge() const { return the << 
101                                                << 
102     G4double GetPDGSpin() const { return thePD << 
103     G4int GetPDGiSpin() const { return thePDGi << 
104     G4int GetPDGiParity() const { return thePD << 
105     G4int GetPDGiConjugation() const { return  << 
106     G4double GetPDGIsospin() const { return th << 
107     G4double GetPDGIsospin3() const { return t << 
108     G4int GetPDGiIsospin() const { return theP << 
109     G4int GetPDGiIsospin3() const { return the << 
110     G4int GetPDGiGParity() const { return theP << 
111                                                << 
112     G4double GetPDGMagneticMoment() const { re << 
113     inline void SetPDGMagneticMoment(G4double  << 
114                                                << 
115     // Gives the anomaly of magnetic moment fo << 
116     G4double CalculateAnomaly() const;         << 
117                                                << 
118     const G4String& GetParticleType() const {  << 
119     const G4String& GetParticleSubType() const << 
120     G4int GetLeptonNumber() const { return the << 
121     G4int GetBaryonNumber() const { return the << 
122                                                << 
123     G4int GetPDGEncoding() const { return theP << 
124     G4int GetAntiPDGEncoding() const { return  << 
125     inline void SetAntiPDGEncoding(G4int aEnco << 
126                                                << 
127     // Returns the number of quark with flavor << 
128     // The value of flavor is assigned as foll << 
129     // 1:d, 2:u, 3:s, 4:c, 5:b, 6:t            << 
130     inline G4int GetQuarkContent(G4int flavor) << 
131     inline G4int GetAntiQuarkContent(G4int fla << 
132                                                << 
133     G4bool IsShortLived() const { return fShor << 
134                                                << 
135     inline G4bool GetPDGStable() const;        << 
136     void SetPDGStable(const G4bool aFlag) { th << 
137                                                << 
138     inline G4double GetPDGLifeTime() const;    << 
139     void SetPDGLifeTime(G4double aLifeTime) {  << 
140                                                << 
141     // Get life time of a generic ion through  << 
142     inline G4double GetIonLifeTime() const;    << 
143                                                << 
144     // Set/Get Decay Table                     << 
145     //   !! Decay Table can be modified !!     << 
146     inline G4DecayTable* GetDecayTable() const << 
147     inline void SetDecayTable(G4DecayTable* aD << 
148                                                << 
149     // Set/Get Process Manager                 << 
150     //   !! Process Manager can be modified !! << 
151     G4ProcessManager* GetProcessManager() cons << 
152     void SetProcessManager(G4ProcessManager* a << 
153                                                << 
154     // Set/Get Tracking Manager; nullptr means << 
155     //   !! Tracking Manager can be modified ! << 
156     G4VTrackingManager* GetTrackingManager() c << 
157     void SetTrackingManager(G4VTrackingManager << 
158                                                << 
159     // Get pointer to the particle table       << 
160     inline G4ParticleTable* GetParticleTable() << 
161                                                << 
162     // Get AtomicNumber and AtomicMass         << 
163     // These properties are defined for nucleu << 
164     inline G4int GetAtomicNumber() const;      << 
165     inline G4int GetAtomicMass() const;        << 
166                                                << 
167     // Prints information of data members.     << 
168     void DumpTable() const;                    << 
169                                                << 
170     // Control flag for output message         << 
171     //  0: Silent                              << 
172     //  1: Warning message                     << 
173     //  2: More                                << 
174     inline void SetVerboseLevel(G4int value);  << 
175     inline G4int GetVerboseLevel() const;      << 
176                                                << 
177     void SetApplyCutsFlag(G4bool);             << 
178     inline G4bool GetApplyCutsFlag() const;    << 
179                                                << 
180     // True only if the particle is G4Ions     << 
181     // (it means that theProcessManager is sam << 
182     inline G4bool IsGeneralIon() const;        << 
183                                                << 
184     // True only if the particle is a G4Muonic << 
185     // (it means that theProcessManager is sam << 
186     inline G4bool IsMuonicAtom() const;        << 
187                                                << 
188     // Returns the process manager master poin << 
189     inline G4ProcessManager* GetMasterProcessM << 
190                                                << 
191     // Sets the shadow master pointer (not to  << 
192     inline void SetMasterProcessManager(G4Proc << 
193                                                << 
194     // Returns the instance ID                 << 
195     inline G4int GetInstanceID() const;        << 
196                                                << 
197     // Returns the private data instance manag << 
198     static const G4PDefManager& GetSubInstance << 
199                                                << 
200     // Clear memory allocated by sub-instance  << 
201     static void Clean();                       << 
202                                                << 
203     void SetParticleDefinitionID(G4int id = -1 << 
204     inline G4int GetParticleDefinitionID() con << 
205                                                << 
206     // The first two methods return "false" an << 
207     // if the particle is not an hypernucleus; << 
208     // "true" and the number of Lambdas bound  << 
209     // Similarly, the last two methods return  << 
210     // respectively, if the particle is not an << 
211     // else, they return "true" and the number << 
212     // bound in the anti-nucleus.              << 
213     // Notice that, for the time being, we are << 
214     // (anti-)Lambda is the only type of (anti << 
215     // in all (anti-)hypernuclei.              << 
216     inline G4bool IsHypernucleus() const;      << 
217     inline G4int GetNumberOfLambdasInHypernucl << 
218     inline G4bool IsAntiHypernucleus() const;  << 
219     inline G4int GetNumberOfAntiLambdasInAntiH << 
220                                                   163 
221   protected:                                      164   protected:
222     // Cannot be used                          << 165       G4int   FillQuarkContents();
223     G4ParticleDefinition();                    << 166       //  calculate quark and anti-quark contents
                                                   >> 167       //  return value is PDG encoding for this particle.
                                                   >> 168       //  It means error if the return value is deffernt from
                                                   >> 169       //  this->thePDGEncoding.
                                                   >> 170 
                                                   >> 171       void   SetParticleSubType(const G4String& subtype);
                                                   >> 172 
                                                   >> 173  public:
                                                   >> 174       void  SetVerboseLevel(G4int value);
                                                   >> 175       G4int GetVerboseLevel() const;
                                                   >> 176       // controle flag for output message
                                                   >> 177       //  0: Silent
                                                   >> 178       //  1: Warning message
                                                   >> 179       //  2: More
224                                                   180 
225     // Calculates quark and anti-quark content << 181   private:
226     // return value is the PDG encoding for th << 182   //  !!!  can not use "copy constructor" nor "default constructor" !!!!
227     // It means error if the return value is d << 183        G4ParticleDefinition(const G4ParticleDefinition &right);
228     // this->thePDGEncoding.                   << 184        G4ParticleDefinition();
229     G4int FillQuarkContents();                 << 185 
230                                                << 186   private:  
231     inline void SetParticleSubType(const G4Str << 187   //  !!!  Assignment operation is forbidden !!!
232                                                << 188       const G4ParticleDefinition & operator=(const G4ParticleDefinition &right);
233     inline void SetAtomicNumber(G4int);        << 
234     inline void SetAtomicMass(G4int);          << 
235                                                << 
236     enum                                       << 
237     {                                          << 
238       NumberOfQuarkFlavor = 6                  << 
239     };                                         << 
240                                                << 
241     //  the number of quark (minus Sign means  << 
242     //  The value of flavor is assigned as fol << 
243     //    0:d, 1:u, 2:s, 3:c, 4:b, 5:t         << 
244     G4int theQuarkContent[NumberOfQuarkFlavor] << 
245     G4int theAntiQuarkContent[NumberOfQuarkFla << 
246                                                   189 
247     G4bool isGeneralIon = false;               << 190   public:
248     G4bool isMuonicAtom = false;               << 191       G4int operator==(const G4ParticleDefinition &right) const;
                                                   >> 192       G4int operator!=(const G4ParticleDefinition &right) const;
249                                                   193 
250   private:                                        194   private:
251     // --- Shadow of master pointers           << 195   //  Values following can not be changed
                                                   >> 196   //  i.e. No Setxxxx Methods for them 
252                                                   197 
253     // Each worker thread can access this fiel << 198       G4String theParticleName;
254     // through this pointer.                   << 199       //  The name of the particle.
255     G4ProcessManager* theProcessManagerShadow  << 200       //  Each object must have its specific name!!
                                                   >> 201 
                                                   >> 202     //    --- following member values must be defined with Units
                                                   >> 203       G4double thePDGMass;
                                                   >> 204       //  The mass of the particle, in units of equivalent energy.
                                                   >> 205 
                                                   >> 206       G4double thePDGWidth;
                                                   >> 207       //  The decay width of the particle, usually the width of a
                                                   >> 208       //  Breit-Wigner function, assuming that you are near the
                                                   >> 209       //  mass center anyway. (in units of equivalent energy)
                                                   >> 210 
                                                   >> 211       G4double thePDGCharge;
                                                   >> 212       //  The charge of the particle.(in units of Coulomb)
                                                   >> 213 
                                                   >> 214     //   ---- following members are quantum number
                                                   >> 215     //         i.e. discrete numbers can be allowded
                                                   >> 216     //        So, you can defined only by using integer in constructor 
                                                   >> 217       G4int thePDGiSpin;
                                                   >> 218       //  The total spin of the particle, also often denoted as
                                                   >> 219       //  capital J, in units of 1/2.
                                                   >> 220       G4double thePDGSpin;
                                                   >> 221       //  The total spin of the particle, in units of 1.
                                                   >> 222 
                                                   >> 223       G4int thePDGiParity;
                                                   >> 224       //  The parity quantum number, in units of 1. If the parity
                                                   >> 225       //  is not defined for this particle, we will set this to 0.
                                                   >> 226 
                                                   >> 227       G4int thePDGiConjugation;
                                                   >> 228       //  This charge conjugation quantum number in units of 1.
                                                   >> 229 
                                                   >> 230       G4int thePDGiIsospin;
                                                   >> 231       G4int thePDGiIsospin3;
                                                   >> 232       //  The isospin and its 3rd-component in units of 1/2.
                                                   >> 233       G4double thePDGIsospin;
                                                   >> 234       G4double thePDGIsospin3;
                                                   >> 235       //  The isospin quantum number in units of 1.
                                                   >> 236 
                                                   >> 237       G4int thePDGiGParity;
                                                   >> 238       //  The value of the G-parity quantum number.
                                                   >> 239 
                                                   >> 240       G4int theLeptonNumber;
                                                   >> 241       //  The lepton quantum number.
                                                   >> 242 
                                                   >> 243       G4int theBaryonNumber;
                                                   >> 244       //  The baryon quantum number.
                                                   >> 245 
                                                   >> 246       G4String theParticleType;
                                                   >> 247       //  More general textual type description of the particle.
                                                   >> 248 
                                                   >> 249       G4String theParticleSubType;
                                                   >> 250       // Textual type description of the particle
                                                   >> 251       // eg. pion, lamda etc.
                                                   >> 252 
                                                   >> 253       G4int thePDGEncoding;
                                                   >> 254       //  The Particle Data Group integer identifier of this particle
                                                   >> 255  
                                                   >> 256       G4int theAntiPDGEncoding;
                                                   >> 257       //  The Particle Data Group integer identifier of the anti-particle
256                                                   258 
257     // This field is used as instance ID.      << 259   protected:
258     G4int g4particleDefinitionInstanceID = 0;  << 260       enum {NumberOfQuarkFlavor = 8};
                                                   >> 261       G4int  theQuarkContent[NumberOfQuarkFlavor];
                                                   >> 262       G4int  theAntiQuarkContent[NumberOfQuarkFlavor];
                                                   >> 263       //  the number of quark (minus Sign means anti-quark) contents
                                                   >> 264       //  The value of flavor is assigned as follows 
                                                   >> 265       //    0:d, 1:u, 2:s, 3:c, 
                                                   >> 266       //    4:b, 5:t, 6:l(down type quark) 7:h(up type quark) 
259                                                   267 
260     // This field helps to use the class G4PDe << 
261     G4PART_DLL static G4PDefManager subInstanc << 
262                                                   268 
263     //  --- Following values can not be change << 269   private:
264     //  --- i.e. No Setxxxx Methods for them   << 270     // Following members can be changed after construction
265                                                   271 
266     // The name of the particle.               << 272      G4bool fShortLivedFlag;
267     // Each object must have its specific name << 273       //  Particles which have true value of this flag 
268     G4String theParticleName = "";             << 274       //  will not be tracked by TrackingManager 
                                                   >> 275 
                                                   >> 276      G4bool thePDGStable;
                                                   >> 277       //  Is an indicator that this particle is stable. It must
                                                   >> 278       //  not decay. If the user tries to assign a kind of decay
                                                   >> 279       //  object to it, it will refuse to take it.
                                                   >> 280 
                                                   >> 281       G4double thePDGLifeTime;
                                                   >> 282       //  Is related to the decay width of the particle. The mean
                                                   >> 283       //  life time is given in seconds.
                                                   >> 284 
                                                   >> 285       class G4DecayTable *theDecayTable;
                                                   >> 286       //  Points DecayTable 
                                                   >> 287  
                                                   >> 288    private:
                                                   >> 289       class G4ProcessManager *theProcessManager;
                                                   >> 290       //  Points to G4ProcessManager
                                                   >> 291 
                                                   >> 292       G4ParticleTable* theParticleTable;
                                                   >> 293  
                                                   >> 294       // ApplyCuts flag 
                                                   >> 295       G4bool                fApplyCutsFlag;
                                                   >> 296      
                                                   >> 297   
                                                   >> 298  private:
                                                   >> 299    G4int verboseLevel;
                                                   >> 300 };
269                                                   301 
270     //  --- Following member values must be de << 302 inline 
                                                   >> 303 G4ParticleTable* G4ParticleDefinition::GetParticleTable()
                                                   >> 304 { 
                                                   >> 305   return theParticleTable; 
                                                   >> 306 }
                                                   >> 307 
                                                   >> 308 inline
                                                   >> 309 G4DecayTable* G4ParticleDefinition::GetDecayTable()
                                                   >> 310 { 
                                                   >> 311   return theDecayTable; 
                                                   >> 312 }
                                                   >> 313 
                                                   >> 314 inline
                                                   >> 315 void          G4ParticleDefinition::SetDecayTable(G4DecayTable* aDecayTable) 
                                                   >> 316 { 
                                                   >> 317   theDecayTable = aDecayTable; 
                                                   >> 318 }
271                                                   319 
272     // The mass of the particle, in units of e << 320 inline 
273     G4double thePDGMass = 0.0;                 << 321 void G4ParticleDefinition::SetApplyCutsFlag(G4bool flag)
                                                   >> 322 {
                                                   >> 323   fApplyCutsFlag = flag;
                                                   >> 324 }
274                                                   325 
275     // The decay width of the particle, usuall << 326 inline 
276     // Breit-Wigner function, assuming that yo << 327 G4bool G4ParticleDefinition::GetApplyCutsFlag() const
277     // mass center anyway. (in units of equiva << 328 {
278     G4double thePDGWidth = 0.0;                << 329   return fApplyCutsFlag;
                                                   >> 330 }
279                                                   331 
280     // The charge of the particle.(in units of << 332 inline 
281     G4double thePDGCharge = 0.0;               << 333 void G4ParticleDefinition::SetVerboseLevel(G4int value)
                                                   >> 334 {
                                                   >> 335    verboseLevel = value;
                                                   >> 336 }
282                                                   337 
283     //   --- Following members are quantum num << 338 inline 
284     //       i.e. discrete numbers can be allo << 339 G4int G4ParticleDefinition::GetVerboseLevel() const
285     //       So, you can define them only by u << 340 {
                                                   >> 341    return verboseLevel;
                                                   >> 342 }
                                                   >> 343 
                                                   >> 344 inline
                                                   >> 345 G4ProcessManager* G4ParticleDefinition::GetProcessManager() const
                                                   >> 346 {
                                                   >> 347     return theProcessManager;
                                                   >> 348 }
286                                                   349 
287     // The total spin of the particle, also of << 350 inline
288     // capital J, in units of 1/2.             << 351 void G4ParticleDefinition::SetProcessManager(G4ProcessManager *aProcessManager)
289     G4int thePDGiSpin = 0;                     << 352 {
                                                   >> 353       theProcessManager = aProcessManager;
                                                   >> 354 }
290                                                   355 
291     // The total spin of the particle, in unit << 356 inline
292     G4double thePDGSpin = 0.0;                 << 357 G4int G4ParticleDefinition::GetQuarkContent(G4int flavor) const 
                                                   >> 358 { 
                                                   >> 359   if ((flavor>0) && (flavor<NumberOfQuarkFlavor)){
                                                   >> 360     return theQuarkContent[flavor-1];
                                                   >> 361   }else {
                                                   >> 362     if (verboseLevel >0) {
                                                   >> 363       G4cout << "Invalid Quark Flavor for G4ParticleDefinition::GetQuarkContent";
                                                   >> 364       G4cout << ": flavor=" << flavor <<G4endl;
                                                   >> 365     }
                                                   >> 366     return 0;
                                                   >> 367   }  
                                                   >> 368 }
                                                   >> 369 
                                                   >> 370 inline
                                                   >> 371 G4int G4ParticleDefinition::GetAntiQuarkContent(G4int flavor) const 
                                                   >> 372 { 
                                                   >> 373   if ((flavor>0) && (flavor<NumberOfQuarkFlavor)){
                                                   >> 374     return theAntiQuarkContent[flavor-1];
                                                   >> 375   }else {
                                                   >> 376     if (verboseLevel >0) {
                                                   >> 377       G4cout <<"Invalid Quark Flavor for G4ParticleDefinition::GetAntiQuarkContent";
                                                   >> 378       G4cout << ": flavor=" << flavor <<G4endl;
                                                   >> 379     }
                                                   >> 380     return 0;
                                                   >> 381   }  
                                                   >> 382 }
293                                                   383 
294     // The parity quantum number, in units of  << 384 inline void G4ParticleDefinition::SetParticleSubType(const G4String& subtype)
295     // is not defined for this particle, we wi << 385 {
296     G4int thePDGiParity = 0;                   << 386   theParticleSubType = subtype;
                                                   >> 387 }
                                                   >> 388 
                                                   >> 389 inline void             G4ParticleDefinition::ResetCuts(){}
                                                   >> 390 
                                                   >> 391 inline void             G4ParticleDefinition::SetCuts(G4double ){}
                                                   >> 392 
                                                   >> 393 inline void             G4ParticleDefinition::ReCalcCuts(){}
                                                   >> 394 
                                                   >> 395 inline G4double         G4ParticleDefinition::GetLengthCuts() const {return -1.0;}
                                                   >> 396 
                                                   >> 397 inline G4double*  G4ParticleDefinition::GetEnergyCuts() const {return 0;}
                                                   >> 398 
                                                   >> 399 inline G4double       G4ParticleDefinition::GetEnergyThreshold(const G4Material* ) const     
                                                   >> 400 {      
                                                   >> 401   return -1.0 * eV;   
                                                   >> 402 }
                                                   >> 403  
                                                   >> 404 inline void             G4ParticleDefinition::SetAntiPDGEncoding(G4int aEncoding)
                                                   >> 405 { 
                                                   >> 406   theAntiPDGEncoding = aEncoding; 
                                                   >> 407 }
                                                   >> 408 
                                                   >> 409 #endif
297                                                   410 
298     // This charge conjugation quantum number  << 
299     G4int thePDGiConjugation = 0;              << 
300                                                   411 
301     // The value of the G-parity quantum numbe << 
302     G4int thePDGiGParity = 0;                  << 
303                                                   412 
304     // The isospin and its 3rd-component in un << 
305     G4int thePDGiIsospin = 0;                  << 
306     G4int thePDGiIsospin3 = 0;                 << 
307                                                   413 
308     // The isospin quantum number in units of  << 
309     G4double thePDGIsospin = 0.0;              << 
310     G4double thePDGIsospin3 = 0.0;             << 
311                                                   414 
312     // The magnetic moment.                    << 
313     G4double thePDGMagneticMoment = 0.0;       << 
314                                                   415 
315     // The lepton quantum number.              << 
316     G4int theLeptonNumber = 0;                 << 
317                                                   416 
318     // The baryon quantum number.              << 
319     G4int theBaryonNumber = 0;                 << 
320                                                   417 
321     // More general textual type description o << 
322     G4String theParticleType = "";             << 
323                                                   418 
324     // Textual type description of the particl << 
325     // eg. pion, lamda etc.                    << 
326     G4String theParticleSubType = "";          << 
327                                                   419 
328     // The Particle Data Group integer identif << 
329     G4int thePDGEncoding = 0;                  << 
330                                                   420 
331     // The Particle Data Group integer identif << 
332     G4int theAntiPDGEncoding = 0;              << 
333                                                   421 
334     // --- Following members can be changed af << 
335                                                   422 
336     // Particles which have true value of this << 
337     // will not be tracked by TrackingManager  << 
338     G4bool fShortLivedFlag = false;            << 
339                                                   423 
340     // Is an indicator that this particle is s << 
341     // not decay. If the user tries to assign  << 
342     // object to it, it will refuse to take it << 
343     G4bool thePDGStable = false;               << 
344                                                   424 
345     // Is related to the decay width of the pa << 
346     // life time is given in seconds.          << 
347     G4double thePDGLifeTime = 0.0;             << 
348                                                   425 
349     // Points DecayTable                       << 
350     G4DecayTable* theDecayTable = nullptr;     << 
351                                                   426 
352     G4ParticleTable* theParticleTable = nullpt << 
353                                                   427 
354     G4int theAtomicNumber = 0;                 << 
355     G4int theAtomicMass = 0;                   << 
356                                                   428 
357     G4int verboseLevel = 1;                    << 
358     G4bool fApplyCutsFlag = false;             << 
359 };                                             << 
360                                                   429 
361 #include "G4ParticleDefinition.icc"            << 
362                                                   430 
363 #endif                                         << 
364                                                   431