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