| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4Track <<
27 // 26 //
28 // Class description: << 27 // $Id: G4Track.hh 94983 2016-01-13 11:02:33Z gcosmo $
29 // 28 //
30 // This class describes the particle under tra << 29 //
31 // It includes information related to tracking << 30 //---------------------------------------------------------------
>> 31 //
>> 32 // G4Track.hh
>> 33 //
>> 34 // Class Description:
>> 35 // This class represents the partilce under tracking.
>> 36 // It includes information related to tracking for examples:
32 // 1) current position/time of the particl 37 // 1) current position/time of the particle,
33 // 2) static particle information, 38 // 2) static particle information,
34 // 3) the pointer to the physical volume w 39 // 3) the pointer to the physical volume where currently
35 // the particle exists 40 // the particle exists
36 << 41 //
37 // Author: Katsuya Amako, KEK - 1995 << 42 //---------------------------------------------------------------
38 // Revisions: Hisaya Kurashige, 1998-2011 << 43 // Modification for G4TouchableHandle 22 Oct. 2001 R.Chytracek
39 // ------------------------------------------- << 44 // Add MaterialCutCouple 08 Oct. 2002 H.Kurashige
40 #ifndef G4Track_hh << 45 // Add SetVelocityTableProperties 02 Apr. 2011 H.Kurashige
41 #define G4Track_hh 1 << 46 // Add fVelocity and Set/GetVelocity 29 Apr. 2011 H.Kurashige
42 << 47 // Use G4VelocityTable 17 AUg. 2011 H.Kurashige
43 #include <cmath> // Include from 'system' << 48
44 #include <map> << 49 #ifndef G4Track_h
45 #include <CLHEP/Units/PhysicalConstants.h> << 50 #define G4Track_h 1
46 << 51
47 #include "globals.hh" // Include fr << 52 #include <cmath> // Include from 'system'
48 #include "trkdefs.hh" // Include DL << 53
49 #include "G4ThreeVector.hh" // Include fr << 54 #include "globals.hh" // Include from 'global'
50 #include "G4LogicalVolume.hh" // Include fr << 55 #include "trkdefs.hh" // Include DLL defs...
51 #include "G4VPhysicalVolume.hh" // Include fr << 56 #include "G4ThreeVector.hh" // Include from 'geometry'
52 #include "G4Allocator.hh" // Include fr << 57 #include "G4LogicalVolume.hh" // Include from 'geometry'
53 #include "G4DynamicParticle.hh" // Include fr << 58 #include "G4VPhysicalVolume.hh" // Include from 'geometry'
54 #include "G4TrackStatus.hh" // Include fr << 59 #include "G4Allocator.hh" // Include from 'particle+matter'
55 #include "G4TouchableHandle.hh" // Include fr << 60 #include "G4DynamicParticle.hh" // Include from 'particle+matter'
>> 61 #include "G4TrackStatus.hh" // Include from 'tracking'
>> 62 #include "G4TouchableHandle.hh" // Include from 'geometry'
56 #include "G4VUserTrackInformation.hh" 63 #include "G4VUserTrackInformation.hh"
57 #include "G4PhysicsModelCatalog.hh" 64 #include "G4PhysicsModelCatalog.hh"
>> 65
58 #include "G4Material.hh" 66 #include "G4Material.hh"
59 67
60 class G4Step; // Forward declaration << 68 class G4Step; // Forward declaration
61 class G4MaterialCutsCouple; 69 class G4MaterialCutsCouple;
>> 70 class G4VelocityTable;
62 class G4VAuxiliaryTrackInformation; 71 class G4VAuxiliaryTrackInformation;
63 class G4VProcess; <<
64 72
>> 73 #include <map>
>> 74
>> 75 //////////////
65 class G4Track 76 class G4Track
>> 77 //////////////
66 { 78 {
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 79
75 G4Track(const G4Track&,G4bool copyTouchabl << 80 //--------
76 // Copy Constructor - copies members oth << 81 public: // With description
>> 82
>> 83 // Constructor
>> 84 G4Track();
>> 85 G4Track(G4DynamicParticle* apValueDynamicParticle,
>> 86 G4double aValueTime,
>> 87 const G4ThreeVector& aValuePosition);
>> 88 // aValueTime is a global time
>> 89 G4Track(const G4Track&);
>> 90 // Copy Constructor copys members other than tracking information
>> 91
>> 92 private:
>> 93 // Hide assignment operator as private
>> 94 G4Track& operator=(const G4Track&);
>> 95
>> 96 //--------
>> 97 public: // With description
77 98
78 ~G4Track(); << 99 // Destrcutor
79 // Destructor << 100 ~G4Track();
80 101
81 inline void* operator new(std::size_t); << 102 // Operators
>> 103 inline void *operator new(size_t);
82 // Override "new" for "G4Allocator". 104 // Override "new" for "G4Allocator".
83 inline void operator delete(void* aTrack); << 105 inline void operator delete(void *aTrack);
84 // Override "delete" for "G4Allocator". 106 // Override "delete" for "G4Allocator".
85 107
86 G4Track& operator=(const G4Track&); << 108 G4bool operator==( const G4Track& );
87 // Assignment operator << 109
>> 110 //--------
>> 111 public: // With description
>> 112 // Copy information of the track (w/o tracking information)
>> 113 void CopyTrackInfo(const G4Track&);
>> 114
>> 115 // Get/Set functions
>> 116 // track ID
>> 117 G4int GetTrackID() const;
>> 118 void SetTrackID(const G4int aValue);
>> 119
>> 120 G4int GetParentID() const;
>> 121 void SetParentID(const G4int aValue);
>> 122
>> 123 // dynamic particle
>> 124 const G4DynamicParticle* GetDynamicParticle() const;
>> 125
>> 126 // particle definition
>> 127 const G4ParticleDefinition* GetParticleDefinition() const;
>> 128 // following method of GetDefinition remains
>> 129 // because of backward compatiblity. It will be removed in future
>> 130 G4ParticleDefinition* GetDefinition() const;
>> 131
>> 132 // position, time
>> 133 const G4ThreeVector& GetPosition() const;
>> 134 void SetPosition(const G4ThreeVector& aValue);
>> 135
>> 136 G4double GetGlobalTime() const;
>> 137 void SetGlobalTime(const G4double aValue);
>> 138 // Time since the event in which the track belongs is created.
>> 139
>> 140 G4double GetLocalTime() const;
>> 141 void SetLocalTime(const G4double aValue);
>> 142 // Time since the current track is created.
88 143
89 inline G4bool operator==(const G4Track&); << 144 G4double GetProperTime() const;
90 inline G4bool operator!=(const G4Track&); << 145 void SetProperTime(const G4double aValue);
91 // Equality operators << 146 // Proper time of the current track
92 147
93 void CopyTrackInfo(const G4Track&, G4bool << 148 // volume, material, touchable
94 // Copy information of the track (w/o tr << 149 G4VPhysicalVolume* GetVolume() const;
>> 150 G4VPhysicalVolume* GetNextVolume() const;
95 151
96 inline G4int GetTrackID() const; << 152 G4Material* GetMaterial() const;
97 inline void SetTrackID(const G4int aValue) << 153 G4Material* GetNextMaterial() const;
98 // Get/Set functions track ID <<
99 154
100 inline G4int GetParentID() const; << 155 const G4MaterialCutsCouple* GetMaterialCutsCouple() const;
101 inline void SetParentID(const G4int aValue << 156 const G4MaterialCutsCouple* GetNextMaterialCutsCouple() const;
102 157
103 inline const G4DynamicParticle* GetDynamic << 158 const G4VTouchable* GetTouchable() const;
104 // Dynamic particle << 159 const G4TouchableHandle& GetTouchableHandle() const;
>> 160 void SetTouchableHandle( const G4TouchableHandle& apValue);
105 161
106 inline const G4ParticleDefinition* GetPart << 162 const G4VTouchable* GetNextTouchable() const;
107 // Particle definition << 163 const G4TouchableHandle& GetNextTouchableHandle() const;
108 inline G4ParticleDefinition* GetDefinition << 164 void SetNextTouchableHandle( const G4TouchableHandle& apValue);
109 // Obsolete, for backwards compatibility <<
110 165
111 inline const G4ThreeVector& GetPosition() << 166 const G4VTouchable* GetOriginTouchable() const;
112 inline void SetPosition(const G4ThreeVecto << 167 const G4TouchableHandle& GetOriginTouchableHandle() const;
113 // Position, time << 168 void SetOriginTouchableHandle( const G4TouchableHandle& apValue);
114 169
115 inline G4double GetGlobalTime() const; << 170 // energy
116 inline void SetGlobalTime(const G4double a << 171 G4double GetKineticEnergy() const;
117 // Time since the event in which the tra << 172 void SetKineticEnergy(const G4double aValue);
118 173
119 inline G4double GetLocalTime() const; << 174 G4double GetTotalEnergy() const;
120 inline void SetLocalTime(const G4double aV <<
121 // Time since the current track is creat <<
122 175
123 inline G4double GetProperTime() const; << 176
124 inline void SetProperTime(const G4double a << 177 // moemtnum
125 // Proper time of the current track << 178 const G4ThreeVector& GetMomentumDirection() const;
>> 179 void SetMomentumDirection(const G4ThreeVector& aValue);
>> 180
>> 181 G4ThreeVector GetMomentum() const;
>> 182
>> 183 // velocity
>> 184 G4double GetVelocity() const;
>> 185 void SetVelocity(G4double val);
>> 186
>> 187 G4double CalculateVelocity() const;
>> 188 G4double CalculateVelocityForOpticalPhoton() const;
126 189
127 inline G4VPhysicalVolume* GetVolume() cons << 190 G4bool UseGivenVelocity() const;
128 inline G4VPhysicalVolume* GetNextVolume() << 191 void UseGivenVelocity(G4bool val);
129 // Volume, material, touchable <<
130 <<
131 inline G4Material* GetMaterial() const; <<
132 inline G4Material* GetNextMaterial() const <<
133 <<
134 inline const G4MaterialCutsCouple* GetMate <<
135 inline const G4MaterialCutsCouple* GetNext <<
136 <<
137 inline const G4VTouchable* GetTouchable() <<
138 inline const G4TouchableHandle& GetTouchab <<
139 inline void SetTouchableHandle(const G4Tou <<
140 <<
141 inline const G4VTouchable* GetNextTouchabl <<
142 inline const G4TouchableHandle& GetNextTou <<
143 inline void SetNextTouchableHandle(const G <<
144 <<
145 inline const G4VTouchable* GetOriginToucha <<
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 192
269 void RemoveAuxiliaryTrackInformation(G4int << 193 // polarization
270 void RemoveAuxiliaryTrackInformation(G4Str << 194 const G4ThreeVector& GetPolarization() const;
271 // Note: G4VAuxiliaryTrackInformation ob << 195 void SetPolarization(const G4ThreeVector& aValue);
>> 196
>> 197 // track status, flags for tracking
>> 198 G4TrackStatus GetTrackStatus() const;
>> 199 void SetTrackStatus(const G4TrackStatus aTrackStatus);
>> 200
>> 201 G4bool IsBelowThreshold() const;
>> 202 void SetBelowThresholdFlag(G4bool value = true);
>> 203 // The flag of "BelowThreshold" is set to true
>> 204 // if this track energy is below threshold energy
>> 205 // in this material determined by the range cut value
>> 206
>> 207 G4bool IsGoodForTracking() const;
>> 208 void SetGoodForTrackingFlag(G4bool value = true);
>> 209 // The flag of "GoodForTracking" is set by processes
>> 210 // if this track should be tracked
>> 211 // even if the energy is below threshold
>> 212
>> 213 // track length
>> 214 G4double GetTrackLength() const;
>> 215 void AddTrackLength(const G4double aValue);
>> 216 // Accumulated the track length
>> 217
>> 218 // step information
>> 219 const G4Step* GetStep() const;
>> 220 void SetStep(const G4Step* aValue);
>> 221
>> 222 G4int GetCurrentStepNumber() const;
>> 223 void IncrementCurrentStepNumber();
>> 224
>> 225 G4double GetStepLength() const;
>> 226 void SetStepLength(G4double value);
>> 227 // Before the end of the AlongStepDoIt loop,StepLength keeps
>> 228 // the initial value which is determined by the shortest geometrical Step
>> 229 // proposed by a physics process. After finishing the AlongStepDoIt,
>> 230 // it will be set equal to 'StepLength' in G4Step.
272 231
273 private: << 232 // vertex (,where this track was created) information
>> 233 const G4ThreeVector& GetVertexPosition() const;
>> 234 void SetVertexPosition(const G4ThreeVector& aValue);
274 235
275 void ClearAuxiliaryTrackInformation(); << 236 const G4ThreeVector& GetVertexMomentumDirection() const;
>> 237 void SetVertexMomentumDirection(const G4ThreeVector& aValue);
276 238
277 // Member data << 239 G4double GetVertexKineticEnergy() const;
>> 240 void SetVertexKineticEnergy(const G4double aValue);
278 241
279 G4ThreeVector fPosition; << 242 const G4LogicalVolume* GetLogicalVolumeAtVertex() const;
280 // Current positon << 243 void SetLogicalVolumeAtVertex(const G4LogicalVolume* );
281 G4double fGlobalTime = 0.0; << 244
282 // Time since the event is created << 245 const G4VProcess* GetCreatorProcess() const;
283 G4double fLocalTime = 0.0; << 246 void SetCreatorProcess(const G4VProcess* aValue);
284 // Time since the track is created << 247
285 G4double fTrackLength = 0.0; << 248 inline void SetCreatorModelIndex(G4int idx);
286 // Accumulated track length << 249
287 << 250 inline const G4String& GetCreatorModelName() const;
288 G4double fVelocity = 0.0; << 251
>> 252 inline G4int GetCreatorModelID() const;
289 253
290 G4TouchableHandle fpTouchable; << 254 // track weight
291 G4TouchableHandle fpNextTouchable; << 255 // These are methods for manipulating a weight for this track.
292 G4TouchableHandle fpOriginTouchable; << 256 G4double GetWeight() const;
293 // Touchable Handle << 257 void SetWeight(G4double aValue);
294 << 258
295 G4DynamicParticle* fpDynamicParticle = nul << 259 // User information
296 mutable G4TrackStatus fTrackStatus = fAliv << 260 G4VUserTrackInformation* GetUserInformation() const;
297 << 261 void SetUserInformation(G4VUserTrackInformation* aValue) const;
298 G4double fStepLength = 0.0; << 262
299 // Before the end of the AlongStepDoIt l << 263 // Velocity table
300 // Step length which is determined by th << 264 static void SetVelocityTableProperties(G4double t_max, G4double t_min, G4int nbin);
>> 265 static G4double GetMaxTOfVelocityTable();
>> 266 static G4double GetMinTOfVelocityTable();
>> 267 static G4int GetNbinOfVelocityTable();
>> 268
>> 269 //---------
>> 270 private:
>> 271 //---------
>> 272 // Member data
>> 273 G4int fCurrentStepNumber; // Total steps number up to now
>> 274 G4ThreeVector fPosition; // Current positon
>> 275 G4double fGlobalTime; // Time since the event is created
>> 276 G4double fLocalTime; // Time since the track is created
>> 277 G4double fTrackLength; // Accumulated track length
>> 278 G4int fParentID;
>> 279 G4int fTrackID;
>> 280 G4double fVelocity;
>> 281
>> 282 G4TouchableHandle fpTouchable;
>> 283 G4TouchableHandle fpNextTouchable;
>> 284 G4TouchableHandle fpOriginTouchable;
>> 285 // Touchable Handle
>> 286
>> 287 G4DynamicParticle* fpDynamicParticle;
>> 288 G4TrackStatus fTrackStatus;
>> 289
>> 290 G4bool fBelowThreshold;
>> 291 // This flag is set to true if this track energy is below
>> 292 // threshold energy in this material determined by the range cut value
>> 293 G4bool fGoodForTracking;
>> 294 // This flag is set by processes if this track should be tracked
>> 295 // even if the energy is below threshold
>> 296
>> 297 G4double fStepLength;
>> 298 // Before the end of the AlongStepDoIt loop, this keeps the initial
>> 299 // Step length which is determined by the shortest geometrical Step
301 // proposed by a physics process. After 300 // proposed by a physics process. After finishing the AlongStepDoIt,
302 // this will be set equal to 'StepLength 301 // this will be set equal to 'StepLength' in G4Step.
303 302
304 G4double fWeight = 1.0; << 303 G4double fWeight;
305 // This is a weight for this track << 304 // This is a weight for this track
306 <<
307 const G4Step* fpStep = nullptr; <<
308 305
309 G4ThreeVector fVtxPosition; << 306 const G4Step* fpStep;
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 307
355 G4bool is_OpticalPhoton = false; << 308 G4ThreeVector fVtxPosition; // (x,y,z) of the vertex
>> 309 G4ThreeVector fVtxMomentumDirection; // Momentum direction at the vertex
>> 310 G4double fVtxKineticEnergy; // Kinetic energy at the vertex
>> 311 const G4LogicalVolume* fpLVAtVertex; //Logical Volume at the vertex
>> 312 const G4VProcess* fpCreatorProcess; // Process which created the track
>> 313 G4int fCreatorModelIndex; // Index of the physics model which created the track
>> 314
>> 315 mutable G4VUserTrackInformation* fpUserInformation;
>> 316
>> 317 // cached values for CalculateVelocity
>> 318 mutable G4Material* prev_mat;
>> 319 mutable G4MaterialPropertyVector* groupvel;
>> 320 mutable G4double prev_velocity;
>> 321 mutable G4double prev_momentum;
356 322
357 G4bool useGivenVelocity = false; << 323 G4bool is_OpticalPhoton;
358 // do not calculate velocity and just us << 324 static G4ThreadLocal G4VelocityTable* velTable;
>> 325
>> 326 G4bool useGivenVelocity;
>> 327 // do not calclulate velocity and just use current fVelocity
359 // if this flag is set 328 // if this flag is set
360 329
361 G4bool fCopyTouchables = true; << 330 mutable std::map<G4int,G4VAuxiliaryTrackInformation*>* fpAuxiliaryTrackInformationMap;
>> 331
>> 332 //--------
>> 333 public:
>> 334 //--------
>> 335
>> 336 void SetAuxiliaryTrackInformation(G4int idx, G4VAuxiliaryTrackInformation* info) const;
>> 337 G4VAuxiliaryTrackInformation* GetAuxiliaryTrackInformation(G4int idx) const;
>> 338 std::map<G4int,G4VAuxiliaryTrackInformation*>* GetAuxiliaryTrackInformationMap() const
>> 339 { return fpAuxiliaryTrackInformationMap; }
>> 340
>> 341 void RemoveAuxiliaryTrackInformation(G4int idx);
>> 342 void RemoveAuxiliaryTrackInformation(G4String& name);
>> 343 // Note: G4VAuxiliaryTrackInformation object itself is *NOT* deleted
>> 344
>> 345 //--------
>> 346 private:
>> 347 //--------
>> 348
>> 349 void ClearAuxiliaryTrackInformation();
362 }; 350 };
363 351
364 #include "G4Track.icc" 352 #include "G4Track.icc"
365 353
366 #endif 354 #endif
367 355