Ignore:
Timestamp:
Nov 5, 2010, 3:45:55 PM (14 years ago)
Author:
garnier
Message:

update ti head

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/track/include/G4Track.icc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4Track.icc,v 1.16 2008/10/24 08:22:20 kurasige Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4Track.icc,v 1.20 2010/10/27 07:53:29 gcosmo Exp $
     28// GEANT4 tag $Name: track-V09-03-09 $
    2929//
    3030//-----------------------------------------------------------------
    … …  
    3838  extern G4DLLIMPORT G4Allocator<G4Track> aTrackAllocator;
    3939#endif
    40 
    41 // Operators
    42 
    43    inline void* G4Track::operator new(size_t)
    44    { void *aTrack;
    45      aTrack = (void *) aTrackAllocator.MallocSingle();
    46      return aTrack;
    47    }
    48       // Override "new" for "G4Allocator".
    49 
    50    inline void G4Track::operator delete(void *aTrack)
    51    { aTrackAllocator.FreeSingle((G4Track *) aTrack);}
    52       // Override "delete" for "G4Allocator".
    53 
    54    inline G4bool G4Track::operator==( const G4Track& s)
    55    { return (this==&s);  }
    56       // Define "==" operator because "G4TrackVector" uses
    57       // "RWPtrOrderdVector" which requires this.
    58 
    59 // Get/Set functions
    60 // dynamic particle
    61    inline const G4DynamicParticle* G4Track::GetDynamicParticle() const
    62    { return fpDynamicParticle; }
    63 
    64 // particle definition
    65    inline G4ParticleDefinition* G4Track::GetDefinition() const
    66    { return fpDynamicParticle->GetDefinition(); }
    67 
    68 // parent track ID
    69    inline G4int G4Track::GetParentID() const
    70    { return fParentID; }
    71 
    72    inline void G4Track::SetParentID(const G4int aValue)
    73    { fParentID = aValue; }
    74 
    75 // current track ID
    76    inline G4int G4Track::GetTrackID() const
    77    { return fTrackID; }
    78 
    79    inline void G4Track::SetTrackID(const G4int aValue)
    80    { fTrackID = aValue; }
    81 
    82 // position
    83    inline const G4ThreeVector& G4Track::GetPosition() const
    84    { return fPosition; }
    85 
    86    inline void G4Track::SetPosition(const G4ThreeVector& aValue)
    87    { fPosition = aValue; }
    88 
    89 // global time
    90    inline G4double G4Track::GetGlobalTime() const
    91    { return fGlobalTime; }
    92 
    93    inline void G4Track::SetGlobalTime(const G4double aValue)
    94    { fGlobalTime = aValue; }
    95      // Time since the event in which the track belongs is created.
    96 
    97 // local time
    98    inline G4double G4Track::GetLocalTime() const
    99    { return fLocalTime; }
    100 
    101    inline void G4Track::SetLocalTime(const G4double aValue)
    102    { fLocalTime = aValue; }
    103       // Time since the current track is created.
    104 
    105 // proper time
    106    inline G4double G4Track::GetProperTime() const
    107    { return fpDynamicParticle->GetProperTime(); }
    108 
    109    inline void G4Track::SetProperTime(const G4double aValue)
    110    { fpDynamicParticle->SetProperTime(aValue); }
    111       // Proper time of the current track
    112 
    113 // volume
    114    inline G4VPhysicalVolume* G4Track::GetVolume() const
    115    { if ( fpTouchable ==0 ) return 0;
    116      return fpTouchable->GetVolume(); }
    117 
    118    inline G4VPhysicalVolume* G4Track::GetNextVolume() const
    119    {  if ( fpNextTouchable ==0 ) return 0;
    120      return fpNextTouchable->GetVolume(); }
    121 
    122 // material
    123    inline
    124     const G4MaterialCutsCouple* G4Track::GetMaterialCutsCouple() const
    125    { return fpStep->GetPreStepPoint()->GetMaterialCutsCouple(); }
    126 
    127    inline
    128     const G4MaterialCutsCouple* G4Track::GetNextMaterialCutsCouple() const
    129    { return fpStep->GetPostStepPoint()->GetMaterialCutsCouple(); }
    130 
    131 // material
    132    inline G4Material* G4Track::GetMaterial() const
    133    { return fpStep->GetPreStepPoint()->GetMaterial(); }
    134 
    135    inline G4Material* G4Track::GetNextMaterial() const
    136    { return fpStep->GetPostStepPoint()->GetMaterial(); }
    137 
    138 
    139 // touchable
    140    inline const G4VTouchable* G4Track::GetTouchable() const
    141    {
    142      return fpTouchable();
    143    }
    144 
    145    inline const G4TouchableHandle& G4Track::GetTouchableHandle() const
    146    {
    147      return fpTouchable;
    148    }
    149 
    150    inline void G4Track::SetTouchableHandle( const G4TouchableHandle& apValue)
    151    {
    152      fpTouchable = apValue;
    153    }
    154 
    155    inline const  G4VTouchable* G4Track::GetNextTouchable() const
    156    {
    157      return fpNextTouchable();
    158    }
    159 
    160    inline const  G4TouchableHandle& G4Track::GetNextTouchableHandle() const
    161    {
    162      return fpNextTouchable;
    163    }
    164 
    165    inline void G4Track::SetNextTouchableHandle( const G4TouchableHandle& apValue)
    166    {
    167      fpNextTouchable = apValue;
    168    }
    169 
    170 
    171 // kinetic energy
    172    inline G4double G4Track::GetKineticEnergy() const
    173    { return fpDynamicParticle->GetKineticEnergy(); }
    174 
    175    inline void G4Track::SetKineticEnergy(const G4double aValue)
    176    { fpDynamicParticle->SetKineticEnergy(aValue); }
    177 
    178 // total energy
    179    inline G4double G4Track::GetTotalEnergy() const
    180    { return fpDynamicParticle->GetTotalEnergy(); }
    181 
    182 // momentum
    183    inline G4ThreeVector G4Track::GetMomentum() const
    184    { return fpDynamicParticle->GetMomentum(); }
    185 
    186 // momentum (direction)
    187   inline const G4ThreeVector& G4Track::GetMomentumDirection() const
    188    { return fpDynamicParticle->GetMomentumDirection(); }
    189 
    190    inline void G4Track::SetMomentumDirection(const G4ThreeVector& aValue)
    191    { fpDynamicParticle->SetMomentumDirection(aValue) ;}
    192 
    193 // polarization
    194    inline const G4ThreeVector& G4Track::GetPolarization() const
    195    { return fpDynamicParticle->GetPolarization(); }
    196 
    197    inline void G4Track::SetPolarization(const G4ThreeVector& aValue)
    198    { fpDynamicParticle->SetPolarization(aValue.x(),
    199                                         aValue.y(),
    200                                         aValue.z()); }
    201 
    202 // track status
    203    inline G4TrackStatus G4Track::GetTrackStatus() const
    204    { return fTrackStatus; }
    205 
    206    inline void G4Track::SetTrackStatus(const G4TrackStatus aTrackStatus)
    207    { fTrackStatus = aTrackStatus; }
    208 
    209 // track length
    210    inline G4double G4Track::GetTrackLength() const
    211    { return fTrackLength; }
    212 
    213    inline void G4Track::AddTrackLength(const G4double aValue)
    214    { fTrackLength += aValue; }
    215       // Accumulated track length
    216 
    217 // step number
    218    inline G4int G4Track::GetCurrentStepNumber() const
    219    { return fCurrentStepNumber; }
    220 
    221    inline void G4Track::IncrementCurrentStepNumber()
    222    { fCurrentStepNumber++; }
    223 
    224 // step length
    225    inline G4double G4Track::GetStepLength() const
    226    { return fStepLength; }
    227 
    228    inline void G4Track::SetStepLength(G4double value)
    229    { fStepLength = value; }
    230 
    231 // vertex (where this track was created) information
    232    inline const G4ThreeVector& G4Track::GetVertexPosition() const
    233    { return fVtxPosition; }
    234 
    235    inline void G4Track::SetVertexPosition(const G4ThreeVector& aValue)
    236    { fVtxPosition = aValue; }
    237 
    238    inline const G4ThreeVector& G4Track::GetVertexMomentumDirection() const
    239    { return fVtxMomentumDirection; }
    240    inline void G4Track::SetVertexMomentumDirection(const G4ThreeVector& aValue)
    241    { fVtxMomentumDirection = aValue ;}
    242 
    243    inline G4double G4Track::GetVertexKineticEnergy() const
    244    { return fVtxKineticEnergy; }
    245 
    246    inline void G4Track::SetVertexKineticEnergy(const G4double aValue)
    247    { fVtxKineticEnergy = aValue; }
    248 
    249    inline  const G4LogicalVolume* G4Track::GetLogicalVolumeAtVertex() const
    250    { return fpLVAtVertex; }
    251 
    252    inline void G4Track::SetLogicalVolumeAtVertex(const G4LogicalVolume* aValue)
    253    { fpLVAtVertex = aValue; }
    254 
    255    inline const G4VProcess* G4Track::GetCreatorProcess() const
    256    { return fpCreatorProcess; }
    257      // If the pointer is 0, this means the track is created
    258      // by the event generator, i.e. the primary track.If it is not
    259      // 0, it points to the process which created this track.
    260 
    261    inline void G4Track::SetCreatorProcess(const G4VProcess* aValue)
    262    { fpCreatorProcess = aValue; }
    263 
    264 // flag for "Below Threshold"
    265    inline G4bool G4Track::IsBelowThreshold() const
    266    { return fBelowThreshold; }
    267 
    268    inline void    G4Track::SetBelowThresholdFlag(G4bool value)
    269    { fBelowThreshold = value; }
    270 
    271 // flag for " Good for Tracking"
    272    inline G4bool  G4Track::IsGoodForTracking() const
    273    { return fGoodForTracking; }
    274 
    275    inline void    G4Track::SetGoodForTrackingFlag(G4bool value)
    276    { fGoodForTracking = value; }
    277 
    278 // track weight
    279    inline void  G4Track::SetWeight(G4double aValue)
    280    { fWeight = aValue; }
    281 
    282    inline G4double G4Track::GetWeight() const
    283    { return fWeight; }
    284 
    285 // user information
    286    inline G4VUserTrackInformation* G4Track::GetUserInformation() const
    287    { return fpUserInformation; }
    288    inline void G4Track::SetUserInformation(G4VUserTrackInformation* aValue)
    289    { fpUserInformation = aValue; }
    290 
    291 
    29240
    29341//-------------------------------------------------------------
    … …  
    29846#include "G4Step.hh"
    29947
     48// Operators
     49
     50   inline void* G4Track::operator new(size_t)
     51   { void *aTrack;
     52     aTrack = (void *) aTrackAllocator.MallocSingle();
     53     return aTrack;
     54   }
     55      // Override "new" for "G4Allocator".
     56
     57   inline void G4Track::operator delete(void *aTrack)
     58   { aTrackAllocator.FreeSingle((G4Track *) aTrack);}
     59      // Override "delete" for "G4Allocator".
     60
     61   inline G4bool G4Track::operator==( const G4Track& s)
     62   { return (this==&s);  }
     63      // Define "==" operator because "G4TrackVector" uses
     64      // "RWPtrOrderdVector" which requires this.
     65
     66// Get/Set functions
     67// dynamic particle
     68   inline const G4DynamicParticle* G4Track::GetDynamicParticle() const
     69   { return fpDynamicParticle; }
     70
     71// particle definition
     72   inline G4ParticleDefinition* G4Track::GetDefinition() const
     73   { return fpDynamicParticle->GetDefinition(); }
     74
     75// particle definition
     76   inline const G4ParticleDefinition* G4Track::GetParticleDefinition() const
     77   { return fpDynamicParticle->GetParticleDefinition(); }
     78
     79// parent track ID
     80   inline G4int G4Track::GetParentID() const
     81   { return fParentID; }
     82
     83   inline void G4Track::SetParentID(const G4int aValue)
     84   { fParentID = aValue; }
     85
     86// current track ID
     87   inline G4int G4Track::GetTrackID() const
     88   { return fTrackID; }
     89
     90   inline void G4Track::SetTrackID(const G4int aValue)
     91   { fTrackID = aValue; }
     92
     93// position
     94   inline const G4ThreeVector& G4Track::GetPosition() const
     95   { return fPosition; }
     96
     97   inline void G4Track::SetPosition(const G4ThreeVector& aValue)
     98   { fPosition = aValue; }
     99
     100// global time
     101   inline G4double G4Track::GetGlobalTime() const
     102   { return fGlobalTime; }
     103
     104   inline void G4Track::SetGlobalTime(const G4double aValue)
     105   { fGlobalTime = aValue; }
     106     // Time since the event in which the track belongs is created.
     107
     108// local time
     109   inline G4double G4Track::GetLocalTime() const
     110   { return fLocalTime; }
     111
     112   inline void G4Track::SetLocalTime(const G4double aValue)
     113   { fLocalTime = aValue; }
     114      // Time since the current track is created.
     115
     116// proper time
     117   inline G4double G4Track::GetProperTime() const
     118   { return fpDynamicParticle->GetProperTime(); }
     119
     120   inline void G4Track::SetProperTime(const G4double aValue)
     121   { fpDynamicParticle->SetProperTime(aValue); }
     122      // Proper time of the current track
     123
     124// volume
     125   inline G4VPhysicalVolume* G4Track::GetVolume() const
     126   { if ( fpTouchable ==0 ) return 0;
     127     return fpTouchable->GetVolume(); }
     128
     129   inline G4VPhysicalVolume* G4Track::GetNextVolume() const
     130   {  if ( fpNextTouchable ==0 ) return 0;
     131     return fpNextTouchable->GetVolume(); }
     132
     133// material
     134   inline
     135    const G4MaterialCutsCouple* G4Track::GetMaterialCutsCouple() const
     136   { return fpStep->GetPreStepPoint()->GetMaterialCutsCouple(); }
     137
     138   inline
     139    const G4MaterialCutsCouple* G4Track::GetNextMaterialCutsCouple() const
     140   { return fpStep->GetPostStepPoint()->GetMaterialCutsCouple(); }
     141
     142// material
     143   inline G4Material* G4Track::GetMaterial() const
     144   { return fpStep->GetPreStepPoint()->GetMaterial(); }
     145
     146   inline G4Material* G4Track::GetNextMaterial() const
     147   { return fpStep->GetPostStepPoint()->GetMaterial(); }
     148
     149
     150// touchable
     151   inline const G4VTouchable* G4Track::GetTouchable() const
     152   {
     153     return fpTouchable();
     154   }
     155
     156   inline const G4TouchableHandle& G4Track::GetTouchableHandle() const
     157   {
     158     return fpTouchable;
     159   }
     160
     161   inline void G4Track::SetTouchableHandle( const G4TouchableHandle& apValue)
     162   {
     163     fpTouchable = apValue;
     164   }
     165
     166   inline const  G4VTouchable* G4Track::GetNextTouchable() const
     167   {
     168     return fpNextTouchable();
     169   }
     170
     171   inline const  G4TouchableHandle& G4Track::GetNextTouchableHandle() const
     172   {
     173     return fpNextTouchable;
     174   }
     175
     176   inline void G4Track::SetNextTouchableHandle( const G4TouchableHandle& apValue)
     177   {
     178     fpNextTouchable = apValue;
     179   }
     180
     181
     182// kinetic energy
     183   inline G4double G4Track::GetKineticEnergy() const
     184   { return fpDynamicParticle->GetKineticEnergy(); }
     185
     186   inline void G4Track::SetKineticEnergy(const G4double aValue)
     187   { fpDynamicParticle->SetKineticEnergy(aValue); }
     188
     189// total energy
     190   inline G4double G4Track::GetTotalEnergy() const
     191   { return fpDynamicParticle->GetTotalEnergy(); }
     192
     193// momentum
     194   inline G4ThreeVector G4Track::GetMomentum() const
     195   { return fpDynamicParticle->GetMomentum(); }
     196
     197// momentum (direction)
     198  inline const G4ThreeVector& G4Track::GetMomentumDirection() const
     199   { return fpDynamicParticle->GetMomentumDirection(); }
     200
     201   inline void G4Track::SetMomentumDirection(const G4ThreeVector& aValue)
     202   { fpDynamicParticle->SetMomentumDirection(aValue) ;}
     203
     204// polarization
     205   inline const G4ThreeVector& G4Track::GetPolarization() const
     206   { return fpDynamicParticle->GetPolarization(); }
     207
     208   inline void G4Track::SetPolarization(const G4ThreeVector& aValue)
     209   { fpDynamicParticle->SetPolarization(aValue.x(),
     210                                        aValue.y(),
     211                                        aValue.z()); }
     212
     213// track status
     214   inline G4TrackStatus G4Track::GetTrackStatus() const
     215   { return fTrackStatus; }
     216
     217   inline void G4Track::SetTrackStatus(const G4TrackStatus aTrackStatus)
     218   { fTrackStatus = aTrackStatus; }
     219
     220// track length
     221   inline G4double G4Track::GetTrackLength() const
     222   { return fTrackLength; }
     223
     224   inline void G4Track::AddTrackLength(const G4double aValue)
     225   { fTrackLength += aValue; }
     226      // Accumulated track length
     227
     228// step number
     229   inline G4int G4Track::GetCurrentStepNumber() const
     230   { return fCurrentStepNumber; }
     231
     232   inline void G4Track::IncrementCurrentStepNumber()
     233   { fCurrentStepNumber++; }
     234
     235// step length
     236   inline G4double G4Track::GetStepLength() const
     237   { return fStepLength; }
     238
     239   inline void G4Track::SetStepLength(G4double value)
     240   { fStepLength = value; }
     241
     242// vertex (where this track was created) information
     243   inline const G4ThreeVector& G4Track::GetVertexPosition() const
     244   { return fVtxPosition; }
     245
     246   inline void G4Track::SetVertexPosition(const G4ThreeVector& aValue)
     247   { fVtxPosition = aValue; }
     248
     249   inline const G4ThreeVector& G4Track::GetVertexMomentumDirection() const
     250   { return fVtxMomentumDirection; }
     251   inline void G4Track::SetVertexMomentumDirection(const G4ThreeVector& aValue)
     252   { fVtxMomentumDirection = aValue ;}
     253
     254   inline G4double G4Track::GetVertexKineticEnergy() const
     255   { return fVtxKineticEnergy; }
     256
     257   inline void G4Track::SetVertexKineticEnergy(const G4double aValue)
     258   { fVtxKineticEnergy = aValue; }
     259
     260   inline  const G4LogicalVolume* G4Track::GetLogicalVolumeAtVertex() const
     261   { return fpLVAtVertex; }
     262
     263   inline void G4Track::SetLogicalVolumeAtVertex(const G4LogicalVolume* aValue)
     264   { fpLVAtVertex = aValue; }
     265
     266   inline const G4VProcess* G4Track::GetCreatorProcess() const
     267   { return fpCreatorProcess; }
     268     // If the pointer is 0, this means the track is created
     269     // by the event generator, i.e. the primary track.If it is not
     270     // 0, it points to the process which created this track.
     271
     272   inline void G4Track::SetCreatorProcess(const G4VProcess* aValue)
     273   { fpCreatorProcess = aValue; }
     274
     275// flag for "Below Threshold"
     276   inline G4bool G4Track::IsBelowThreshold() const
     277   { return fBelowThreshold; }
     278
     279   inline void    G4Track::SetBelowThresholdFlag(G4bool value)
     280   { fBelowThreshold = value; }
     281
     282// flag for " Good for Tracking"
     283   inline G4bool  G4Track::IsGoodForTracking() const
     284   { return fGoodForTracking; }
     285
     286   inline void    G4Track::SetGoodForTrackingFlag(G4bool value)
     287   { fGoodForTracking = value; }
     288
     289// track weight
     290   inline void  G4Track::SetWeight(G4double aValue)
     291   { fWeight = aValue; }
     292
     293   inline G4double G4Track::GetWeight() const
     294   { return fWeight; }
     295
     296// user information
     297   inline G4VUserTrackInformation* G4Track::GetUserInformation() const
     298   { return fpUserInformation; }
     299   inline void G4Track::SetUserInformation(G4VUserTrackInformation* aValue)
     300   { fpUserInformation = aValue; }
     301
    300302   inline const G4Step* G4Track::GetStep() const
    301303   { return fpStep; }
    302304
    303305   inline void G4Track::SetStep(const G4Step* aValue)
    304    { fpStep = (aValue); }
    305 
    306 
    307 
    308 
    309 
     306   { fpStep = aValue; }
Note: See TracChangeset for help on using the changeset viewer.