source: trunk/source/geometry/magneticfield/include/G4FieldTrack.icc@ 1315

Last change on this file since 1315 was 1231, checked in by garnier, 16 years ago

update from CVS
File size: 10.5 KB
Line 
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,v 1.21 2006/11/13 18:24:35 gcosmo Exp $
28// GEANT4 tag $Name: $
29//
30// -------------------------------------------------------------------
31
32// Implementation methods for the embedded class G4ChargeState
33// ----------------------------
34inline G4FieldTrack::
35G4ChargeState::G4ChargeState(G4double charge,
36 G4double magnetic_dipole_moment,
37 G4double electric_dipole_moment,
38 G4double magnetic_charge)
39{
40 fCharge= charge;
41 fMagn_dipole= magnetic_dipole_moment;
42 fElec_dipole= electric_dipole_moment;
43 fMagneticCharge= magnetic_charge;
44}
45
46inline G4FieldTrack::
47G4ChargeState::G4ChargeState(
48 const G4FieldTrack::G4ChargeState& right )
49{
50 fCharge= right.fCharge;
51 fMagn_dipole= right.fMagn_dipole;
52 fElec_dipole= right.fElec_dipole;
53 fMagneticCharge= right.fMagneticCharge;
54}
55
56inline void
57G4FieldTrack::InitialiseSpin( const G4ThreeVector& Spin )
58{
59 // static G4ThreeVector ZeroVec(0.0, 0.0, 0.0);
60
61 fSpin = Spin;
62 // New Member ?? G4bool fHasSpin;
63 // fHasSpin = (fSpin != ZeroVec);
64}
65
66inline void G4FieldTrack::
67G4ChargeState::SetChargeAndMoments(G4double charge,
68 G4double magnetic_dipole_moment,
69 G4double electric_dipole_moment,
70 G4double magnetic_charge )
71 // Revise the charge and potentially all moments.
72 // By default do not change mdm, edm, mag charge.
73{
74 fCharge= charge;
75 if( magnetic_dipole_moment < DBL_MAX) fMagn_dipole= magnetic_dipole_moment;
76 if( electric_dipole_moment < DBL_MAX) fElec_dipole= electric_dipole_moment;
77 if( magnetic_charge < DBL_MAX) fMagneticCharge= magnetic_charge;
78}
79
80inline
81G4FieldTrack::G4FieldTrack( const G4FieldTrack& rStVec )
82 : fDistanceAlongCurve( rStVec.fDistanceAlongCurve),
83 fKineticEnergy( rStVec.fKineticEnergy ),
84 fRestMass_c2( rStVec.fRestMass_c2),
85 fLabTimeOfFlight( rStVec.fLabTimeOfFlight ),
86 fProperTimeOfFlight( rStVec.fProperTimeOfFlight ),
87 // fMomentumModulus( rStVec.fMomentumModulus ),
88 fSpin( rStVec.fSpin ),
89 fMomentumDir( rStVec.fMomentumDir ),
90 fChargeState( rStVec.fChargeState )
91{
92 SixVector[0]= rStVec.SixVector[0];
93 SixVector[1]= rStVec.SixVector[1];
94 SixVector[2]= rStVec.SixVector[2];
95 SixVector[3]= rStVec.SixVector[3];
96 SixVector[4]= rStVec.SixVector[4];
97 SixVector[5]= rStVec.SixVector[5];
98
99 // fpChargeState= new G4ChargeState( *rStVec.fpChargeState );
100 // Can share charge state only when using handles etc
101 // fpChargeState = rStVec.fpChargeState;
102}
103
104inline
105G4FieldTrack::~G4FieldTrack()
106{
107 // delete fpChargeState;
108}
109
110inline G4FieldTrack&
111G4FieldTrack::SetCurvePnt(const G4ThreeVector& pPosition,
112 const G4ThreeVector& pMomentum,
113 G4double s_curve )
114{
115 SixVector[0] = pPosition.x();
116 SixVector[1] = pPosition.y();
117 SixVector[2] = pPosition.z();
118
119 SixVector[3] = pMomentum.x();
120 SixVector[4] = pMomentum.y();
121 SixVector[5] = pMomentum.z();
122
123 fMomentumDir = pMomentum.unit();
124
125 fDistanceAlongCurve= s_curve;
126
127 return *this;
128}
129
130inline
131G4ThreeVector G4FieldTrack::GetPosition() const
132{
133 G4ThreeVector myPosition( SixVector[0], SixVector[1], SixVector[2] );
134 return myPosition;
135}
136
137inline
138void G4FieldTrack::SetPosition( G4ThreeVector pPosition)
139{
140 SixVector[0] = pPosition.x();
141 SixVector[1] = pPosition.y();
142 SixVector[2] = pPosition.z();
143}
144
145inline
146const G4ThreeVector& G4FieldTrack::GetMomentumDir() const
147{
148 // G4ThreeVector myMomentum( SixVector[3], SixVector[4], SixVector[5] );
149 // return myVelocity;
150 return fMomentumDir;
151}
152
153inline
154G4ThreeVector G4FieldTrack::GetMomentumDirection() const
155{
156 return fMomentumDir;
157}
158
159inline
160G4double G4FieldTrack::GetCurveLength() const
161{
162 return fDistanceAlongCurve;
163}
164
165inline
166void G4FieldTrack::SetCurveLength(G4double nCurve_s)
167{
168 fDistanceAlongCurve= nCurve_s;
169}
170
171inline
172G4double G4FieldTrack::GetKineticEnergy() const
173{
174 return fKineticEnergy;
175}
176
177inline
178void G4FieldTrack::SetKineticEnergy(G4double newKinEnergy)
179{
180 fKineticEnergy=newKinEnergy;
181}
182
183inline
184G4ThreeVector G4FieldTrack::GetSpin() const
185{
186 return fSpin;
187}
188
189inline
190void G4FieldTrack::SetSpin(G4ThreeVector nSpin)
191{
192 fSpin=nSpin;
193}
194
195inline
196G4double G4FieldTrack::GetLabTimeOfFlight() const
197{
198 return fLabTimeOfFlight;
199}
200
201inline
202void G4FieldTrack::SetLabTimeOfFlight(G4double nTOF)
203{
204 fLabTimeOfFlight=nTOF;
205}
206
207inline
208G4double G4FieldTrack::GetProperTimeOfFlight() const
209{
210 return fProperTimeOfFlight;
211}
212
213inline
214void G4FieldTrack::SetProperTimeOfFlight(G4double nTOF)
215{
216 fProperTimeOfFlight=nTOF;
217}
218
219inline
220void G4FieldTrack::SetMomentumDir(G4ThreeVector newMomDir)
221{
222 fMomentumDir= newMomDir;
223}
224
225inline
226G4ThreeVector G4FieldTrack::GetMomentum() const
227{
228 return G4ThreeVector( SixVector[3], SixVector[4], SixVector[5] );
229}
230
231inline
232void G4FieldTrack::SetMomentum(G4ThreeVector pMomentum)
233{
234 SixVector[3] = pMomentum.x();
235 SixVector[4] = pMomentum.y();
236 SixVector[5] = pMomentum.z();
237
238 fMomentumDir = pMomentum.unit();
239}
240
241inline
242G4double G4FieldTrack::GetCharge() const
243{
244 return fChargeState.GetCharge();
245}
246
247// Dump values to array
248//
249// note that momentum direction is not saved
250
251inline
252void G4FieldTrack::DumpToArray(G4double valArr[ncompSVEC] ) const
253{
254 valArr[0]=SixVector[0];
255 valArr[1]=SixVector[1];
256 valArr[2]=SixVector[2];
257 valArr[3]=SixVector[3];
258 valArr[4]=SixVector[4];
259 valArr[5]=SixVector[5];
260
261 G4ThreeVector Momentum(valArr[3],valArr[4],valArr[5]);
262
263 // G4double mass_in_Kg;
264 // mass_in_Kg = fEnergy / velocity_mag_sq * (1-velocity_mag_sq/c_squared);
265 // valArr[6]= mass_in_Kg;
266
267 // The following components may or may not be integrated.
268 valArr[6]= fKineticEnergy;
269
270 // valArr[6]=fEnergy; // When it is integrated over, do this ...
271 valArr[7]=fLabTimeOfFlight;
272 valArr[8]=fProperTimeOfFlight;
273 valArr[9]=fSpin.x();
274 valArr[10]=fSpin.y();
275 valArr[11]=fSpin.z();
276 // valArr[13]=fMomentumDir.x();
277 // valArr[14]=fMomentumDir.y();
278 // valArr[15]=fMomentumDir.z();
279 // valArr[]=fDistanceAlongCurve;
280}
281
282// Load values from array
283//
284// note that momentum direction must-be/is normalised
285
286inline
287void G4FieldTrack::LoadFromArray(const G4double valArrIn[ncompSVEC], G4int noVarsIntegrated)
288{
289 G4int i;
290
291 // Fill the variables not integrated with zero -- so it's clear !!
292 static G4double valArr[ncompSVEC];
293 for( i=0; i<noVarsIntegrated; i++){
294 valArr[i]= valArrIn[i];
295 }
296 for( i=noVarsIntegrated; i<ncompSVEC; i++) {
297 valArr[i]= 0.0;
298 }
299
300 SixVector[0]=valArr[0];
301 SixVector[1]=valArr[1];
302 SixVector[2]=valArr[2];
303 SixVector[3]=valArr[3];
304 SixVector[4]=valArr[4];
305 SixVector[5]=valArr[5];
306
307 G4ThreeVector Momentum(valArr[3],valArr[4],valArr[5]);
308
309 G4double momentum_square= Momentum.mag2();
310 fMomentumDir= Momentum.unit();
311
312 fKineticEnergy = momentum_square /
313 (std::sqrt(momentum_square+fRestMass_c2*fRestMass_c2)
314 + fRestMass_c2 );
315 // The above equation is stable for small and large momenta
316
317 // The following components may or may not be
318 // integrated over -- integration is optional
319 // fKineticEnergy= valArr[6];
320
321 fLabTimeOfFlight=valArr[7];
322 fProperTimeOfFlight=valArr[8];
323 fSpin=G4ThreeVector(valArr[9],valArr[10],valArr[11]);
324 // fMomentumDir=G4ThreeVector(valArr[13],valArr[14],valArr[15]);
325 // fDistanceAlongCurve= valArr[];
326}
327
328inline
329G4FieldTrack & G4FieldTrack::operator = ( const G4FieldTrack& rStVec )
330{
331 if (&rStVec == this) return *this;
332
333 SixVector[0]= rStVec.SixVector[0];
334 SixVector[1]= rStVec.SixVector[1];
335 SixVector[2]= rStVec.SixVector[2];
336 SixVector[3]= rStVec.SixVector[3];
337 SixVector[4]= rStVec.SixVector[4];
338 SixVector[5]= rStVec.SixVector[5];
339 SetCurveLength( rStVec.GetCurveLength() );
340
341 fKineticEnergy= rStVec.fKineticEnergy;
342 SetLabTimeOfFlight( rStVec.GetLabTimeOfFlight() );
343 SetProperTimeOfFlight( rStVec.GetProperTimeOfFlight() );
344 SetSpin( rStVec.GetSpin() );
345 // SetMomentumModulus( rStVec.GetMomentumModulus());
346 SetMomentumDir( rStVec.fMomentumDir );
347
348 fChargeState= rStVec.fChargeState;
349 // (*fpChargeState)= *(rStVec.fpChargeState);
350 // fpChargeState= rStVec.fpChargeState; // Handles!!
351 return *this;
352}
353
354void
355G4FieldTrack::UpdateFourMomentum( G4double kineticEnergy,
356 const G4ThreeVector& momentumDirection )
357{
358 G4double momentum_mag = std::sqrt(kineticEnergy*kineticEnergy
359 +2.0*fRestMass_c2*kineticEnergy);
360 G4ThreeVector momentumVector= momentum_mag * momentumDirection;
361
362 SetMomentum( momentumVector ); // Also sets direction (from unit)
363 fMomentumDir= momentumDirection;
364 fKineticEnergy= kineticEnergy;
365}
366
367void G4FieldTrack::UpdateState( const G4ThreeVector& position,
368 G4double laboratoryTimeOfFlight,
369 const G4ThreeVector& momentumDirection,
370 G4double kineticEnergy
371 )
372{
373 // SetCurvePnt( position, momentumVector, s_curve=0.0);
374 SetPosition( position);
375 fLabTimeOfFlight= laboratoryTimeOfFlight;
376 fDistanceAlongCurve= 0.0;
377
378 UpdateFourMomentum( kineticEnergy, momentumDirection);
379}
Note: See TracBrowser for help on using the repository browser.