Geant4  10.01.p02
G4FieldTrack.icc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4FieldTrack.icc 88944 2015-03-16 16:11:10Z gcosmo $
28 //
29 // -------------------------------------------------------------------
30 
31 inline
32 G4FieldTrack::G4FieldTrack( const G4FieldTrack& rStVec )
33  : fDistanceAlongCurve( rStVec.fDistanceAlongCurve),
34  fKineticEnergy( rStVec.fKineticEnergy ),
35  fRestMass_c2( rStVec.fRestMass_c2),
36  fLabTimeOfFlight( rStVec.fLabTimeOfFlight ),
37  fProperTimeOfFlight( rStVec.fProperTimeOfFlight ),
38  // fMomentumModulus( rStVec.fMomentumModulus ),
39  fPolarization( rStVec.fPolarization ),
40  fMomentumDir( rStVec.fMomentumDir ),
41  fChargeState( rStVec.fChargeState )
42 {
43  SixVector[0]= rStVec.SixVector[0];
44  SixVector[1]= rStVec.SixVector[1];
45  SixVector[2]= rStVec.SixVector[2];
46  SixVector[3]= rStVec.SixVector[3];
47  SixVector[4]= rStVec.SixVector[4];
48  SixVector[5]= rStVec.SixVector[5];
49 
50  // fpChargeState= new G4ChargeState( *rStVec.fpChargeState );
51  // Can share charge state only when using handles etc
52  // fpChargeState = rStVec.fpChargeState;
53 }
54 
55 inline
56 G4FieldTrack::~G4FieldTrack()
57 {
58  // delete fpChargeState;
59 }
60 
61 inline G4FieldTrack&
62 G4FieldTrack::SetCurvePnt(const G4ThreeVector& pPosition,
63  const G4ThreeVector& pMomentum,
64  G4double s_curve )
65 {
66  SixVector[0] = pPosition.x();
67  SixVector[1] = pPosition.y();
68  SixVector[2] = pPosition.z();
69 
70  SixVector[3] = pMomentum.x();
71  SixVector[4] = pMomentum.y();
72  SixVector[5] = pMomentum.z();
73 
74  fMomentumDir = (pMomentum.mag2() > 0.0) ?
75  pMomentum.unit() : G4ThreeVector( 0.0, 0.0, 0.0 );
76 
77  fDistanceAlongCurve= s_curve;
78 
79  return *this;
80 }
81 
82 inline
83 G4ThreeVector G4FieldTrack::GetPosition() const
84 {
85  G4ThreeVector myPosition( SixVector[0], SixVector[1], SixVector[2] );
86  return myPosition;
87 }
88 
89 inline
90 void G4FieldTrack::SetPosition( G4ThreeVector pPosition)
91 {
92  SixVector[0] = pPosition.x();
93  SixVector[1] = pPosition.y();
94  SixVector[2] = pPosition.z();
95 }
96 
97 inline
98 const G4ThreeVector& G4FieldTrack::GetMomentumDir() const
99 {
100  // G4ThreeVector myMomentum( SixVector[3], SixVector[4], SixVector[5] );
101  // return myVelocity;
102  return fMomentumDir;
103 }
104 
105 inline
106 G4ThreeVector G4FieldTrack::GetMomentumDirection() const
107 {
108  return fMomentumDir;
109 }
110 
111 inline
112 G4double G4FieldTrack::GetCurveLength() const
113 {
114  return fDistanceAlongCurve;
115 }
116 
117 inline
118 void G4FieldTrack::SetCurveLength(G4double nCurve_s)
119 {
120  fDistanceAlongCurve= nCurve_s;
121 }
122 
123 inline
124 G4double G4FieldTrack::GetKineticEnergy() const
125 {
126  return fKineticEnergy;
127 }
128 
129 inline
130 void G4FieldTrack::SetKineticEnergy(G4double newKinEnergy)
131 {
132  fKineticEnergy=newKinEnergy;
133 }
134 
135 inline
136 G4ThreeVector G4FieldTrack::GetPolarization() const
137 {
138  return fPolarization;
139 }
140 
141 inline
142 void G4FieldTrack::SetPolarization(const G4ThreeVector& vecPlz)
143 {
144  fPolarization= vecPlz;
145 }
146 
147 inline
148 G4double G4FieldTrack::GetLabTimeOfFlight() const
149 {
150  return fLabTimeOfFlight;
151 }
152 
153 inline
154 void G4FieldTrack::SetLabTimeOfFlight(G4double nTOF)
155 {
156  fLabTimeOfFlight=nTOF;
157 }
158 
159 inline
160 G4double G4FieldTrack::GetProperTimeOfFlight() const
161 {
162  return fProperTimeOfFlight;
163 }
164 
165 inline
166 void G4FieldTrack::SetProperTimeOfFlight(G4double nTOF)
167 {
168  fProperTimeOfFlight=nTOF;
169 }
170 
171 inline
172 void G4FieldTrack::SetMomentumDir(G4ThreeVector newMomDir)
173 {
174  fMomentumDir= newMomDir;
175 }
176 
177 inline
178 G4ThreeVector G4FieldTrack::GetMomentum() const
179 {
180  return G4ThreeVector( SixVector[3], SixVector[4], SixVector[5] );
181 }
182 
183 inline
184 void G4FieldTrack::SetMomentum(G4ThreeVector pMomentum)
185 {
186  SixVector[3] = pMomentum.x();
187  SixVector[4] = pMomentum.y();
188  SixVector[5] = pMomentum.z();
189 
190  fMomentumDir = pMomentum.unit();
191 }
192 
193 inline
194 G4double G4FieldTrack::GetCharge() const
195 {
196  return fChargeState.GetCharge();
197 }
198 
199 // Dump values to array
200 //
201 // note that momentum direction is not saved
202 
203 inline
204 void G4FieldTrack::DumpToArray(G4double valArr[ncompSVEC] ) const
205 {
206  valArr[0]=SixVector[0];
207  valArr[1]=SixVector[1];
208  valArr[2]=SixVector[2];
209  valArr[3]=SixVector[3];
210  valArr[4]=SixVector[4];
211  valArr[5]=SixVector[5];
212 
213  G4ThreeVector Momentum(valArr[3],valArr[4],valArr[5]);
214 
215  // G4double mass_in_Kg;
216  // mass_in_Kg = fEnergy / velocity_mag_sq * (1-velocity_mag_sq/c_squared);
217  // valArr[6]= mass_in_Kg;
218 
219  // The following components may or may not be integrated.
220  valArr[6]= fKineticEnergy;
221 
222  // valArr[6]=fEnergy; // When it is integrated over, do this ...
223  valArr[7]=fLabTimeOfFlight;
224  valArr[8]=fProperTimeOfFlight;
225  valArr[9]=fPolarization.x();
226  valArr[10]=fPolarization.y();
227  valArr[11]=fPolarization.z();
228  // valArr[13]=fMomentumDir.x();
229  // valArr[14]=fMomentumDir.y();
230  // valArr[15]=fMomentumDir.z();
231  // valArr[]=fDistanceAlongCurve;
232 }
233 
234 inline
235 G4FieldTrack & G4FieldTrack::operator = ( const G4FieldTrack& rStVec )
236 {
237  if (&rStVec == this) return *this;
238 
239  SixVector[0]= rStVec.SixVector[0];
240  SixVector[1]= rStVec.SixVector[1];
241  SixVector[2]= rStVec.SixVector[2];
242  SixVector[3]= rStVec.SixVector[3];
243  SixVector[4]= rStVec.SixVector[4];
244  SixVector[5]= rStVec.SixVector[5];
245  SetCurveLength( rStVec.GetCurveLength() );
246 
247  fKineticEnergy= rStVec.fKineticEnergy;
248  fRestMass_c2= rStVec.fRestMass_c2;
249  SetLabTimeOfFlight( rStVec.GetLabTimeOfFlight() );
250  SetProperTimeOfFlight( rStVec.GetProperTimeOfFlight() );
251  SetPolarization( rStVec.GetPolarization() );
252  fMomentumDir= rStVec.fMomentumDir;
253 
254  fChargeState= rStVec.fChargeState;
255  // (*fpChargeState)= *(rStVec.fpChargeState);
256  // fpChargeState= rStVec.fpChargeState; // Handles!!
257  return *this;
258 }
259 
260 inline void
261 G4FieldTrack::UpdateFourMomentum( G4double kineticEnergy,
262  const G4ThreeVector& momentumDirection )
263 {
264  G4double momentum_mag = std::sqrt(kineticEnergy*kineticEnergy
265  +2.0*fRestMass_c2*kineticEnergy);
266  G4ThreeVector momentumVector= momentum_mag * momentumDirection;
267 
268  // SetMomentum( momentumVector ); // Set direction (from unit): used sqrt, div
269  SixVector[3] = momentumVector.x();
270  SixVector[4] = momentumVector.y();
271  SixVector[5] = momentumVector.z();
272 
273  fMomentumDir= momentumDirection; // Set directly to avoid inaccuracy.
274  fKineticEnergy= kineticEnergy;
275 }
276 
277 inline void G4FieldTrack::UpdateState( const G4ThreeVector& position,
278  G4double laboratoryTimeOfFlight,
279  const G4ThreeVector& momentumDirection,
280  G4double kineticEnergy
281  )
282 {
283  // SetCurvePnt( position, momentumVector, s_curve=0.0);
284  SetPosition( position);
285  fLabTimeOfFlight= laboratoryTimeOfFlight;
286  fDistanceAlongCurve= 0.0;
287 
288  UpdateFourMomentum( kineticEnergy, momentumDirection);
289 }