Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/track/include/G4Track.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 /track/include/G4Track.hh (Version 11.3.0) and /track/include/G4Track.hh (Version 3.1)


                                                   >>   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 // G4Track                                     <<   8 // $Id: G4Track.hh,v 1.10 2001/01/18 12:25:08 kurasige Exp $
                                                   >>   9 // GEANT4 tag $Name: geant4-03-01 $
 27 //                                                 10 //
 28 // Class description:                          << 
 29 //                                                 11 //
 30 // This class describes the particle under tra <<  12 //---------------------------------------------------------------
 31 // It includes information related to tracking <<  13 //
                                                   >>  14 // G4Track.hh
                                                   >>  15 //
                                                   >>  16 // Class Description:
                                                   >>  17 //   This class represents the partilce under tracking.
                                                   >>  18 //   It includes information related to tracking for examples:
 32 //     1) current position/time of the particl     19 //     1) current position/time of the particle,
 33 //     2) static particle information,             20 //     2) static particle information,
 34 //     3) the pointer to the physical volume w     21 //     3) the pointer to the physical volume where currently
 35 //        the particle exists                  <<  22 //        the particle exists,
                                                   >>  23 //
                                                   >>  24 // Contact:
                                                   >>  25 //   Questions and comments to this code should be sent to
                                                   >>  26 //     Katsuya Amako  (e-mail: Katsuya.Amako@kek.jp)
                                                   >>  27 //     Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
                                                   >>  28 //
                                                   >>  29 //---------------------------------------------------------------
 36                                                    30 
 37 // Author: Katsuya Amako, KEK - 1995           <<  31 #ifndef G4Track_h
 38 // Revisions: Hisaya Kurashige, 1998-2011      <<  32 #define G4Track_h 1
 39 // ------------------------------------------- <<  33 
 40 #ifndef G4Track_hh                             <<  34 #include "globals.hh"                 // Include from 'global'
 41 #define G4Track_hh 1                           <<  35 #include "G4ThreeVector.hh"           // Include from 'geometry'
 42                                                <<  36 #include "G4LogicalVolume.hh"         // Include from 'geometry'
 43 #include <cmath>  // Include from 'system'     <<  37 #include "G4VPhysicalVolume.hh"       // Include from 'geometry'
 44 #include <map>                                 <<  38 #include "G4Allocator.hh"             // Include from 'particle+matter'
 45 #include <CLHEP/Units/PhysicalConstants.h>     <<  39 #include "G4DynamicParticle.hh"       // Include from 'particle+matter'
 46                                                <<  40 #include "G4TrackStatus.hh"           // Include from 'tracking'
 47 #include "globals.hh"            // Include fr <<  41 #include "G4VTouchable.hh"            // Include from 'geometry'
 48 #include "trkdefs.hh"            // Include DL << 
 49 #include "G4ThreeVector.hh"      // Include fr << 
 50 #include "G4LogicalVolume.hh"    // Include fr << 
 51 #include "G4VPhysicalVolume.hh"  // Include fr << 
 52 #include "G4Allocator.hh"        // Include fr << 
 53 #include "G4DynamicParticle.hh"  // Include fr << 
 54 #include "G4TrackStatus.hh"      // Include fr << 
 55 #include "G4TouchableHandle.hh"  // Include fr << 
 56 #include "G4VUserTrackInformation.hh"              42 #include "G4VUserTrackInformation.hh"
 57 #include "G4PhysicsModelCatalog.hh"            <<  43 
 58 #include "G4Material.hh"                           44 #include "G4Material.hh"
 59                                                    45 
 60 class G4Step;  // Forward declaration          <<  46 class G4Step;                         // Forward declaration
 61 class G4MaterialCutsCouple;                    << 
 62 class G4VAuxiliaryTrackInformation;            << 
 63 class G4VProcess;                              << 
 64                                                    47 
                                                   >>  48 //////////////
 65 class G4Track                                      49 class G4Track
                                                   >>  50 ////////////// 
 66 {                                                  51 {
 67   public:                                      << 
 68     G4Track();                                 << 
 69       // Default constructor                   << 
 70     G4Track(G4DynamicParticle* apValueDynamicP << 
 71             G4double aValueTime,               << 
 72             const G4ThreeVector& aValuePositio << 
 73       // Constructor - aValueTime is a global  << 
 74                                                    52 
 75     G4Track(const G4Track&,G4bool copyTouchabl <<  53 //--------
 76       // Copy Constructor - copies members oth <<  54 public: // With description
 77                                                    55 
 78     ~G4Track();                                <<  56 // Constructor
 79       // Destructor                            <<  57    G4Track();
                                                   >>  58    G4Track(const G4Track&);
                                                   >>  59    G4Track(G4DynamicParticle* apValueDynamicParticle,
                                                   >>  60            G4double aValueTime,
                                                   >>  61            const G4ThreeVector& aValuePosition);
                                                   >>  62       // aValueTime is a global time
                                                   >>  63 
                                                   >>  64    G4Track& operator=(const  G4Track&);
                                                   >>  65 //--------
                                                   >>  66 public: 
 80                                                    67 
 81     inline void* operator new(std::size_t);    <<  68 // Destrcutor
                                                   >>  69    ~G4Track();
                                                   >>  70 
                                                   >>  71 // Operators
                                                   >>  72    inline void *operator new(size_t);
 82       // Override "new" for "G4Allocator".         73       // Override "new" for "G4Allocator".
 83     inline void operator delete(void* aTrack); <<  74    inline void operator delete(void *aTrack);
 84       // Override "delete" for "G4Allocator".      75       // Override "delete" for "G4Allocator".
 85                                                    76 
 86     G4Track& operator=(const G4Track&);        <<  77    int operator==( const G4Track& s);
 87       // Assignment operator                   <<  78       // Define "==" operator because "G4TrackVector" uses 
 88                                                <<  79       //"RWPtrOrderdVector" which requires this.
 89     inline G4bool operator==(const G4Track&);  << 
 90     inline G4bool operator!=(const G4Track&);  << 
 91       // Equality operators                    << 
 92                                                    80 
 93     void CopyTrackInfo(const G4Track&, G4bool  <<  81 //--------
 94       // Copy information of the track (w/o tr <<  82 public: // With description
 95                                                    83 
 96     inline G4int GetTrackID() const;           <<  84 // Get/Set functions
 97     inline void SetTrackID(const G4int aValue) <<  85   // track ID
 98       // Get/Set functions track ID            <<  86    G4int GetTrackID() const;
                                                   >>  87    void SetTrackID(const G4int aValue);
 99                                                    88 
100     inline G4int GetParentID() const;          <<  89    G4int GetParentID() const;
101     inline void SetParentID(const G4int aValue <<  90    void SetParentID(const G4int aValue);
102                                                    91 
103     inline const G4DynamicParticle* GetDynamic <<  92   // dynamic particle 
104       // Dynamic particle                      <<  93    const G4DynamicParticle* GetDynamicParticle() const;
105                                                    94 
106     inline const G4ParticleDefinition* GetPart <<  95   // particle definition
107       // Particle definition                   <<  96    G4ParticleDefinition* GetDefinition() const;
108     inline G4ParticleDefinition* GetDefinition << 
109       // Obsolete, for backwards compatibility << 
110                                                    97 
111     inline const G4ThreeVector& GetPosition()  <<  98    // position, time 
112     inline void SetPosition(const G4ThreeVecto <<  99    const G4ThreeVector& GetPosition() const;
113       // Position, time                        << 100    void SetPosition(const G4ThreeVector& aValue);
114                                                   101 
115     inline G4double GetGlobalTime() const;     << 102    G4double GetGlobalTime() const;
116     inline void SetGlobalTime(const G4double a << 103    void SetGlobalTime(const G4double aValue);
117       // Time since the event in which the tra << 104      // Time since the event in which the track belongs is created.
118                                                   105 
119     inline G4double GetLocalTime() const;      << 106    G4double GetLocalTime() const;
120     inline void SetLocalTime(const G4double aV << 107    void SetLocalTime(const G4double aValue);
121       // Time since the current track is creat << 108       // Time since the current track is created.
122                                                   109 
123     inline G4double GetProperTime() const;     << 110    G4double GetProperTime() const;
124     inline void SetProperTime(const G4double a << 111    void SetProperTime(const G4double aValue);
125       // Proper time of the current track         112       // Proper time of the current track
126                                                   113 
127     inline G4VPhysicalVolume* GetVolume() cons << 114   // volume, material, touchable
128     inline G4VPhysicalVolume* GetNextVolume()  << 115    G4VPhysicalVolume* GetVolume() const;
129       // Volume, material, touchable           << 116    G4VPhysicalVolume* GetNextVolume() const;
130                                                << 117 
131     inline G4Material* GetMaterial() const;    << 118    G4Material* GetMaterial() const;
132     inline G4Material* GetNextMaterial() const << 119    G4Material* GetNextMaterial() const;
133                                                << 120 
134     inline const G4MaterialCutsCouple* GetMate << 121    const G4VTouchable* GetTouchable() const;
135     inline const G4MaterialCutsCouple* GetNext << 122    void SetTouchable(const G4VTouchable* apValue);
136                                                << 123 
137     inline const G4VTouchable* GetTouchable()  << 124    const G4VTouchable* GetNextTouchable() const;
138     inline const G4TouchableHandle& GetTouchab << 125    void SetNextTouchable(const G4VTouchable* apValue);
139     inline void SetTouchableHandle(const G4Tou << 126 
140                                                << 127   // energy
141     inline const G4VTouchable* GetNextTouchabl << 128    G4double GetKineticEnergy() const;
142     inline const G4TouchableHandle& GetNextTou << 129    void SetKineticEnergy(const G4double aValue);
143     inline void SetNextTouchableHandle(const G << 130 
144                                                << 131    G4double GetTotalEnergy() const;
145     inline const G4VTouchable* GetOriginToucha << 132 
146     inline const G4TouchableHandle& GetOriginT << 
147     inline void SetOriginTouchableHandle(const << 
148                                                << 
149     inline G4double GetKineticEnergy() const;  << 
150     inline G4double GetTotalEnergy() const;    << 
151     inline void SetKineticEnergy(const G4doubl << 
152       // Energy                                << 
153                                                << 
154     inline G4ThreeVector GetMomentum() const;  << 
155     inline const G4ThreeVector& GetMomentumDir << 
156     inline void SetMomentumDirection(const G4T << 
157       // Momentum                              << 
158                                                << 
159     inline G4double GetVelocity() const;       << 
160     inline void SetVelocity(G4double val);     << 
161       // Velocity                              << 
162                                                << 
163     inline G4double CalculateVelocity() const; << 
164     G4double CalculateVelocityForOpticalPhoton << 
165                                                << 
166     inline G4bool UseGivenVelocity() const;    << 
167     inline void UseGivenVelocity(G4bool val);  << 
168                                                << 
169     inline const G4ThreeVector& GetPolarizatio << 
170     inline void SetPolarization(const G4ThreeV << 
171       // Polarization                          << 
172                                                << 
173     inline G4TrackStatus GetTrackStatus() cons << 
174     inline void SetTrackStatus(const G4TrackSt << 
175       // Track status, flags for tracking      << 
176                                                << 
177     inline G4bool IsBelowThreshold() const;    << 
178     inline void SetBelowThresholdFlag(G4bool v << 
179       // The flag of "BelowThreshold" is set t << 
180       // If this track energy is below thresho << 
181       // in this material is determined by the << 
182                                                << 
183     inline G4bool IsGoodForTracking() const;   << 
184     inline void SetGoodForTrackingFlag(G4bool  << 
185       // The flag of "GoodForTracking" is set  << 
186       // if this track should be tracked       << 
187       // even if the energy is below threshold << 
188                                                << 
189     inline G4double GetTrackLength() const;    << 
190     inline void AddTrackLength(const G4double  << 
191       // Accumulated track length              << 
192                                                << 
193     inline const G4Step* GetStep() const;      << 
194     inline void SetStep(const G4Step* aValue); << 
195       // Step information                      << 
196                                                << 
197     inline G4int GetCurrentStepNumber() const; << 
198     inline void IncrementCurrentStepNumber();  << 
199                                                << 
200     inline G4double GetStepLength() const;     << 
201     inline void SetStepLength(G4double value); << 
202       // Before the end of the AlongStepDoIt() << 
203       // the initial value which is determined << 
204       // proposed by a physics process. After  << 
205       // it will be set equal to 'StepLength'  << 
206                                                << 
207     inline const G4ThreeVector& GetVertexPosit << 
208     inline void SetVertexPosition(const G4Thre << 
209       // Vertex (where this track was created) << 
210                                                << 
211     inline const G4ThreeVector& GetVertexMomen << 
212     inline void SetVertexMomentumDirection(con << 
213                                                << 
214     inline G4double GetVertexKineticEnergy() c << 
215     inline void SetVertexKineticEnergy(const G << 
216                                                << 
217     inline const G4LogicalVolume* GetLogicalVo << 
218     inline void SetLogicalVolumeAtVertex(const << 
219                                                << 
220     inline const G4VProcess* GetCreatorProcess << 
221     inline void SetCreatorProcess(const G4VPro << 
222                                                << 
223     inline void SetCreatorModelID(const G4int  << 
224     inline G4int GetCreatorModelID() const;    << 
225     inline G4int GetCreatorModelIndex() const; << 
226     inline const G4String GetCreatorModelName( << 
227       // Identification of the physics model t << 
228       // each of the three information (ID, in << 
229       // (the model ID and its name are suppos << 
230       // code, whereas the index is meant for  << 
231                                                << 
232     inline const G4ParticleDefinition* GetPare << 
233     inline void SetParentResonanceDef(const G4 << 
234     inline G4int GetParentResonanceID() const; << 
235     inline void SetParentResonanceID(const G4i << 
236     inline G4bool HasParentResonance() const;  << 
237     inline G4int GetParentResonancePDGEncoding << 
238     inline G4String GetParentResonanceName() c << 
239     inline G4double GetParentResonanceMass() c << 
240       // Because short-lived resonances (e.g.  << 
241       // do not have corresponding track objec << 
242       // by a resonance parent, these methods  << 
243       // regarding this short-lived parent.    << 
244       // The ID is a unique (integer) identifi << 
245       // corresponds to the rounded integer of << 
246       // in keV), which allows to know if two  << 
247       // from the same parent resonance: this  << 
248       // the parent-track-ID (fParentID) which << 
249       // ancestor which is not a short-lived r << 
250       // a corresponding track object).        << 
251       // In the case of a track non originatin << 
252       // the above "Get" methods return, respe << 
253       // 0, "", 0.                             << 
254                                                << 
255     inline G4double GetWeight() const;         << 
256     inline void SetWeight(G4double aValue);    << 
257       // Track weight; methods for manipulatin << 
258                                                << 
259     inline G4VUserTrackInformation* GetUserInf << 
260     inline void SetUserInformation(G4VUserTrac << 
261       // User information                      << 
262                                                << 
263     void SetAuxiliaryTrackInformation(G4int id << 
264                                       G4VAuxil << 
265     G4VAuxiliaryTrackInformation* GetAuxiliary << 
266     inline std::map<G4int, G4VAuxiliaryTrackIn << 
267            GetAuxiliaryTrackInformationMap() c << 
268                                                << 
269     void RemoveAuxiliaryTrackInformation(G4int << 
270     void RemoveAuxiliaryTrackInformation(G4Str << 
271       // Note: G4VAuxiliaryTrackInformation ob << 
272                                                << 
273   private:                                     << 
274                                                << 
275     void ClearAuxiliaryTrackInformation();     << 
276                                                << 
277     // Member data                             << 
278                                                << 
279     G4ThreeVector fPosition;                   << 
280       // Current positon                       << 
281     G4double fGlobalTime = 0.0;                << 
282       // Time since the event is created       << 
283     G4double fLocalTime = 0.0;                 << 
284       // Time since the track is created       << 
285     G4double fTrackLength = 0.0;               << 
286       // Accumulated track length              << 
287                                                   133  
288     G4double fVelocity = 0.0;                  << 134   // moemtnum
                                                   >> 135    const G4ThreeVector& GetMomentumDirection() const;
                                                   >> 136    void SetMomentumDirection(const G4ThreeVector& aValue);
                                                   >> 137 
                                                   >> 138    G4ThreeVector GetMomentum() const;
                                                   >> 139 
                                                   >> 140    G4double GetVelocity() const;
                                                   >> 141 
                                                   >> 142 
                                                   >> 143   // polarization 
                                                   >> 144    const G4ThreeVector& GetPolarization() const;
                                                   >> 145    void SetPolarization(const G4ThreeVector& aValue);
                                                   >> 146 
                                                   >> 147   // track status, flags for tracking
                                                   >> 148    G4TrackStatus GetTrackStatus() const;
                                                   >> 149    void SetTrackStatus(const G4TrackStatus aTrackStatus);
                                                   >> 150 
                                                   >> 151    G4bool IsBelowThreshold() const;
                                                   >> 152    void   SetBelowThresholdFlag(G4bool value = true);
                                                   >> 153      // The flag of "BelowThreshold" is set to true 
                                                   >> 154      // if this track energy is below threshold energy 
                                                   >> 155      //  in this material determined by the range cut value
                                                   >> 156 
                                                   >> 157    G4bool IsGoodForTracking() const;
                                                   >> 158    void   SetGoodForTrackingFlag(G4bool value = true);
                                                   >> 159      // The flag of "GoodForTracking" is set by processes 
                                                   >> 160      // if this track should be tracked
                                                   >> 161      // even if the energy is below threshold
                                                   >> 162 
                                                   >> 163   // track length
                                                   >> 164    G4double GetTrackLength() const;
                                                   >> 165    void AddTrackLength(const G4double aValue);
                                                   >> 166       // Accumulated the track length
                                                   >> 167 
                                                   >> 168   // step information
                                                   >> 169    const G4Step* GetStep() const;
                                                   >> 170    void SetStep(const G4Step* aValue);
                                                   >> 171 
                                                   >> 172    G4int GetCurrentStepNumber() const;
                                                   >> 173    void IncrementCurrentStepNumber();
                                                   >> 174 
                                                   >> 175    G4double GetStepLength() const;
                                                   >> 176    void SetStepLength(G4double value);
                                                   >> 177       // Before the end of the AlongStepDoIt loop,StepLength keeps 
                                                   >> 178       // the initial value which is determined by the shortest geometrical Step 
                                                   >> 179       // proposed by a physics process. After finishing the AlongStepDoIt,
                                                   >> 180       // it will be set equal to 'StepLength' in G4Step.
289                                                   181 
290     G4TouchableHandle fpTouchable;             << 182   // vertex (,where this track was created) information  
291     G4TouchableHandle fpNextTouchable;         << 183    const G4ThreeVector& GetVertexPosition() const;
292     G4TouchableHandle fpOriginTouchable;       << 184    void SetVertexPosition(const G4ThreeVector& aValue);
293       // Touchable Handle                      << 185 
294                                                << 186    const G4ThreeVector& GetVertexMomentumDirection() const;
295     G4DynamicParticle* fpDynamicParticle = nul << 187    void SetVertexMomentumDirection(const G4ThreeVector& aValue);
296     mutable G4TrackStatus fTrackStatus = fAliv << 188 
297                                                << 189    G4double GetVertexKineticEnergy() const;
298     G4double fStepLength = 0.0;                << 190    void SetVertexKineticEnergy(const G4double aValue);
299       // Before the end of the AlongStepDoIt l << 191 
300       // Step length which is determined by th << 192    G4LogicalVolume* GetLogicalVolumeAtVertex() const;
                                                   >> 193    void SetLogicalVolumeAtVertex(G4LogicalVolume* );
                                                   >> 194 
                                                   >> 195    const G4VProcess* GetCreatorProcess() const;
                                                   >> 196    void SetCreatorProcess(G4VProcess* aValue);
                                                   >> 197 
                                                   >> 198   // track weight
                                                   >> 199      // These are methods for manipulating a weight for this track.
                                                   >> 200      // The track weight is used by G4VEvtBiasMechanism 
                                                   >> 201      // to execute inclusive simulation for hadronic/electomagnetic shower
                                                   >> 202      // and neutron transportation etc. 
                                                   >> 203    G4double GetWeight() const;
                                                   >> 204    void     SetWeight(G4double aValue);
                                                   >> 205 
                                                   >> 206   // User information
                                                   >> 207   G4VUserTrackInformation* GetUserInformation() const;
                                                   >> 208   void SetUserInformation(G4VUserTrackInformation* aValue);
                                                   >> 209 
                                                   >> 210 //---------
                                                   >> 211    private:
                                                   >> 212 //---------
                                                   >> 213 
                                                   >> 214 // Member data
                                                   >> 215    G4int fCurrentStepNumber;       // Total steps number up to now
                                                   >> 216    G4ThreeVector fPosition;        // Current positon
                                                   >> 217    G4double fGlobalTime;           // Time since the event is created
                                                   >> 218    G4double fLocalTime;            // Time since the track is created
                                                   >> 219    G4double fTrackLength;          // Accumulated track length
                                                   >> 220    G4int fParentID;
                                                   >> 221    G4int fTrackID;
                                                   >> 222 
                                                   >> 223    const G4VTouchable* fpTouchable;
                                                   >> 224    const G4VTouchable* fpNextTouchable;
                                                   >> 225 
                                                   >> 226    G4DynamicParticle* fpDynamicParticle;
                                                   >> 227    G4TrackStatus fTrackStatus;
                                                   >> 228 
                                                   >> 229    G4bool  fBelowThreshold;
                                                   >> 230    // This flag is set to true if this track energy is below
                                                   >> 231    // threshold energy in this material determined by the range cut value
                                                   >> 232    G4bool  fGoodForTracking;
                                                   >> 233    // This flag is set by processes if this track should be tracked
                                                   >> 234    // even if the energy is below threshold
                                                   >> 235 
                                                   >> 236    G4double fStepLength;           
                                                   >> 237       // Before the end of the AlongStepDoIt loop, this keeps the initial 
                                                   >> 238       // Step length which is determined by the shortest geometrical Step 
301       // proposed by a physics process. After     239       // proposed by a physics process. After finishing the AlongStepDoIt,
302       // this will be set equal to 'StepLength    240       // this will be set equal to 'StepLength' in G4Step.
303                                                   241 
304     G4double fWeight = 1.0;                    << 242    G4double fWeight;
305       // This is a weight for this track       << 243      // This is a weight for this track used by G4VEvtBiasMechanism 
                                                   >> 244      // to execute inclusive simulation for hadronic/electomagnetic shower
                                                   >> 245      // and neutron transportation etc. 
                                                   >> 246 
                                                   >> 247    const G4Step* fpStep;
                                                   >> 248 
                                                   >> 249    G4ThreeVector fVtxPosition;          // (x,y,z) of the vertex
                                                   >> 250    G4ThreeVector fVtxMomentumDirection; // Momentum direction at the vertex
                                                   >> 251    G4double fVtxKineticEnergy;          // Kinetic energy at the vertex
                                                   >> 252    G4LogicalVolume* fpLVAtVertex;       //Logical Volume at the vertex
                                                   >> 253    G4VProcess* fpCreatorProcess;        // Process which created the track
                                                   >> 254    
                                                   >> 255    G4VUserTrackInformation* fpUserInformation;
                                                   >> 256 };
                                                   >> 257 #include "G4Step.hh"
                                                   >> 258 #include "G4Track.icc"
                                                   >> 259 
                                                   >> 260 #endif
                                                   >> 261 
                                                   >> 262 
                                                   >> 263 
                                                   >> 264 
                                                   >> 265 
                                                   >> 266 
                                                   >> 267 
                                                   >> 268 
                                                   >> 269 
                                                   >> 270 
306                                                   271 
307     const G4Step* fpStep = nullptr;            << 
308                                                   272 
309     G4ThreeVector fVtxPosition;                << 
310       // (x,y,z) of the vertex                 << 
311     G4ThreeVector fVtxMomentumDirection;       << 
312       // Momentum direction at the vertex      << 
313     G4double fVtxKineticEnergy = 0.0;          << 
314       // Kinetic energy at the vertex          << 
315     const G4LogicalVolume* fpLVAtVertex = null << 
316       // Logical Volume at the vertex          << 
317     const G4VProcess* fpCreatorProcess = nullp << 
318       // Process which created the track       << 
319                                                << 
320     mutable G4VUserTrackInformation* fpUserInf << 
321                                                << 
322     mutable G4Material* prev_mat = nullptr;    << 
323     mutable G4MaterialPropertyVector* groupvel << 
324     mutable G4double prev_velocity = 0.0;      << 
325     mutable G4double prev_momentum = 0.0;      << 
326       // cached values for CalculateVelocity   << 
327                                                << 
328     mutable std::map<G4int, G4VAuxiliaryTrackI << 
329             fpAuxiliaryTrackInformationMap = n << 
330                                                << 
331     G4int fCurrentStepNumber = 0;              << 
332       // Total steps number up to now          << 
333                                                << 
334     G4int fCreatorModelID = -1;                << 
335       // ID of the physics model which created << 
336                                                << 
337     const G4ParticleDefinition* fParentResonan << 
338       // Pointer to the particle definition of << 
339       // in the case that the track is produce << 
340       // (which does not have a corresponding  << 
341     G4int fParentResonanceID = 0;              << 
342       // Unique ID for the parent resonance, i << 
343       // is produced by a resonance parent, el << 
344                                                << 
345     G4int fParentID = 0;                       << 
346     G4int fTrackID = 0;                        << 
347                                                << 
348     G4bool fBelowThreshold = false;            << 
349       // This flag is set to true if this trac << 
350       // threshold energy in this material det << 
351     G4bool fGoodForTracking = false;           << 
352       // This flag is set by processes if this << 
353       // even if the energy is below threshold << 
354                                                << 
355     G4bool is_OpticalPhoton = false;           << 
356                                                << 
357     G4bool useGivenVelocity = false;           << 
358       // do not calculate velocity and just us << 
359       // if this flag is set                   << 
360                                                   273 
361     G4bool fCopyTouchables = true;             << 
362 };                                             << 
363                                                   274 
364 #include "G4Track.icc"                         << 
365                                                   275 
366 #endif                                         << 
367                                                   276