Gabriele Cosmo
380 lines
10 KiB
Plaintext
380 lines
10 KiB
Plaintext
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
// $Id: G4FieldTrack.icc,v 1.21 2006/11/13 18:24:35 gcosmo Exp $
|
|
// GEANT4 tag $Name: geant4-09-01 $
|
|
//
|
|
// -------------------------------------------------------------------
|
|
|
|
// Implementation methods for the embedded class G4ChargeState
|
|
// ----------------------------
|
|
inline G4FieldTrack::
|
|
G4ChargeState::G4ChargeState(G4double charge,
|
|
G4double magnetic_dipole_moment,
|
|
G4double electric_dipole_moment,
|
|
G4double magnetic_charge)
|
|
{
|
|
fCharge= charge;
|
|
fMagn_dipole= magnetic_dipole_moment;
|
|
fElec_dipole= electric_dipole_moment;
|
|
fMagneticCharge= magnetic_charge;
|
|
}
|
|
|
|
inline G4FieldTrack::
|
|
G4ChargeState::G4ChargeState(
|
|
const G4FieldTrack::G4ChargeState& right )
|
|
{
|
|
fCharge= right.fCharge;
|
|
fMagn_dipole= right.fMagn_dipole;
|
|
fElec_dipole= right.fElec_dipole;
|
|
fMagneticCharge= right.fMagneticCharge;
|
|
}
|
|
|
|
inline void
|
|
G4FieldTrack::InitialiseSpin( const G4ThreeVector& Spin )
|
|
{
|
|
// static G4ThreeVector ZeroVec(0.0, 0.0, 0.0);
|
|
|
|
fSpin = Spin;
|
|
// New Member ?? G4bool fHasSpin;
|
|
// fHasSpin = (fSpin != ZeroVec);
|
|
}
|
|
|
|
inline void G4FieldTrack::
|
|
G4ChargeState::SetChargeAndMoments(G4double charge,
|
|
G4double magnetic_dipole_moment,
|
|
G4double electric_dipole_moment,
|
|
G4double magnetic_charge )
|
|
// Revise the charge and potentially all moments.
|
|
// By default do not change mdm, edm, mag charge.
|
|
{
|
|
fCharge= charge;
|
|
if( magnetic_dipole_moment < DBL_MAX) fMagn_dipole= magnetic_dipole_moment;
|
|
if( electric_dipole_moment < DBL_MAX) fElec_dipole= electric_dipole_moment;
|
|
if( magnetic_charge < DBL_MAX) fMagneticCharge= magnetic_charge;
|
|
}
|
|
|
|
inline
|
|
G4FieldTrack::G4FieldTrack( const G4FieldTrack& rStVec )
|
|
: fDistanceAlongCurve( rStVec.fDistanceAlongCurve),
|
|
fKineticEnergy( rStVec.fKineticEnergy ),
|
|
fRestMass_c2( rStVec.fRestMass_c2),
|
|
fLabTimeOfFlight( rStVec.fLabTimeOfFlight ),
|
|
fProperTimeOfFlight( rStVec.fProperTimeOfFlight ),
|
|
// fMomentumModulus( rStVec.fMomentumModulus ),
|
|
fSpin( rStVec.fSpin ),
|
|
fMomentumDir( rStVec.fMomentumDir ),
|
|
fChargeState( rStVec.fChargeState )
|
|
{
|
|
SixVector[0]= rStVec.SixVector[0];
|
|
SixVector[1]= rStVec.SixVector[1];
|
|
SixVector[2]= rStVec.SixVector[2];
|
|
SixVector[3]= rStVec.SixVector[3];
|
|
SixVector[4]= rStVec.SixVector[4];
|
|
SixVector[5]= rStVec.SixVector[5];
|
|
|
|
// fpChargeState= new G4ChargeState( *rStVec.fpChargeState );
|
|
// Can share charge state only when using handles etc
|
|
// fpChargeState = rStVec.fpChargeState;
|
|
}
|
|
|
|
inline
|
|
G4FieldTrack::~G4FieldTrack()
|
|
{
|
|
// delete fpChargeState;
|
|
}
|
|
|
|
inline G4FieldTrack&
|
|
G4FieldTrack::SetCurvePnt(const G4ThreeVector& pPosition,
|
|
const G4ThreeVector& pMomentum,
|
|
G4double s_curve )
|
|
{
|
|
SixVector[0] = pPosition.x();
|
|
SixVector[1] = pPosition.y();
|
|
SixVector[2] = pPosition.z();
|
|
|
|
SixVector[3] = pMomentum.x();
|
|
SixVector[4] = pMomentum.y();
|
|
SixVector[5] = pMomentum.z();
|
|
|
|
fMomentumDir = pMomentum.unit();
|
|
|
|
fDistanceAlongCurve= s_curve;
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline
|
|
G4ThreeVector G4FieldTrack::GetPosition() const
|
|
{
|
|
G4ThreeVector myPosition( SixVector[0], SixVector[1], SixVector[2] );
|
|
return myPosition;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetPosition( G4ThreeVector pPosition)
|
|
{
|
|
SixVector[0] = pPosition.x();
|
|
SixVector[1] = pPosition.y();
|
|
SixVector[2] = pPosition.z();
|
|
}
|
|
|
|
inline
|
|
const G4ThreeVector& G4FieldTrack::GetMomentumDir() const
|
|
{
|
|
// G4ThreeVector myMomentum( SixVector[3], SixVector[4], SixVector[5] );
|
|
// return myVelocity;
|
|
return fMomentumDir;
|
|
}
|
|
|
|
inline
|
|
G4ThreeVector G4FieldTrack::GetMomentumDirection() const
|
|
{
|
|
return fMomentumDir;
|
|
}
|
|
|
|
inline
|
|
G4double G4FieldTrack::GetCurveLength() const
|
|
{
|
|
return fDistanceAlongCurve;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetCurveLength(G4double nCurve_s)
|
|
{
|
|
fDistanceAlongCurve= nCurve_s;
|
|
}
|
|
|
|
inline
|
|
G4double G4FieldTrack::GetKineticEnergy() const
|
|
{
|
|
return fKineticEnergy;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetKineticEnergy(G4double newKinEnergy)
|
|
{
|
|
fKineticEnergy=newKinEnergy;
|
|
}
|
|
|
|
inline
|
|
G4ThreeVector G4FieldTrack::GetSpin() const
|
|
{
|
|
return fSpin;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetSpin(G4ThreeVector nSpin)
|
|
{
|
|
fSpin=nSpin;
|
|
}
|
|
|
|
inline
|
|
G4double G4FieldTrack::GetLabTimeOfFlight() const
|
|
{
|
|
return fLabTimeOfFlight;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetLabTimeOfFlight(G4double nTOF)
|
|
{
|
|
fLabTimeOfFlight=nTOF;
|
|
}
|
|
|
|
inline
|
|
G4double G4FieldTrack::GetProperTimeOfFlight() const
|
|
{
|
|
return fProperTimeOfFlight;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetProperTimeOfFlight(G4double nTOF)
|
|
{
|
|
fProperTimeOfFlight=nTOF;
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetMomentumDir(G4ThreeVector newMomDir)
|
|
{
|
|
fMomentumDir= newMomDir;
|
|
}
|
|
|
|
inline
|
|
G4ThreeVector G4FieldTrack::GetMomentum() const
|
|
{
|
|
return G4ThreeVector( SixVector[3], SixVector[4], SixVector[5] );
|
|
}
|
|
|
|
inline
|
|
void G4FieldTrack::SetMomentum(G4ThreeVector pMomentum)
|
|
{
|
|
SixVector[3] = pMomentum.x();
|
|
SixVector[4] = pMomentum.y();
|
|
SixVector[5] = pMomentum.z();
|
|
|
|
fMomentumDir = pMomentum.unit();
|
|
}
|
|
|
|
inline
|
|
G4double G4FieldTrack::GetCharge() const
|
|
{
|
|
return fChargeState.GetCharge();
|
|
}
|
|
|
|
// Dump values to array
|
|
//
|
|
// note that momentum direction is not saved
|
|
|
|
inline
|
|
void G4FieldTrack::DumpToArray(G4double valArr[ncompSVEC] ) const
|
|
{
|
|
valArr[0]=SixVector[0];
|
|
valArr[1]=SixVector[1];
|
|
valArr[2]=SixVector[2];
|
|
valArr[3]=SixVector[3];
|
|
valArr[4]=SixVector[4];
|
|
valArr[5]=SixVector[5];
|
|
|
|
G4ThreeVector Momentum(valArr[3],valArr[4],valArr[5]);
|
|
|
|
// G4double mass_in_Kg;
|
|
// mass_in_Kg = fEnergy / velocity_mag_sq * (1-velocity_mag_sq/c_squared);
|
|
// valArr[6]= mass_in_Kg;
|
|
|
|
// The following components may or may not be integrated.
|
|
valArr[6]= fKineticEnergy;
|
|
|
|
// valArr[6]=fEnergy; // When it is integrated over, do this ...
|
|
valArr[7]=fLabTimeOfFlight;
|
|
valArr[8]=fProperTimeOfFlight;
|
|
valArr[9]=fSpin.x();
|
|
valArr[10]=fSpin.y();
|
|
valArr[11]=fSpin.z();
|
|
// valArr[13]=fMomentumDir.x();
|
|
// valArr[14]=fMomentumDir.y();
|
|
// valArr[15]=fMomentumDir.z();
|
|
// valArr[]=fDistanceAlongCurve;
|
|
}
|
|
|
|
// Load values from array
|
|
//
|
|
// note that momentum direction must-be/is normalised
|
|
|
|
inline
|
|
void G4FieldTrack::LoadFromArray(const G4double valArrIn[ncompSVEC], G4int noVarsIntegrated)
|
|
{
|
|
G4int i;
|
|
|
|
// Fill the variables not integrated with zero -- so it's clear !!
|
|
static G4double valArr[ncompSVEC];
|
|
for( i=0; i<noVarsIntegrated; i++){
|
|
valArr[i]= valArrIn[i];
|
|
}
|
|
for( i=noVarsIntegrated; i<ncompSVEC; i++) {
|
|
valArr[i]= 0.0;
|
|
}
|
|
|
|
SixVector[0]=valArr[0];
|
|
SixVector[1]=valArr[1];
|
|
SixVector[2]=valArr[2];
|
|
SixVector[3]=valArr[3];
|
|
SixVector[4]=valArr[4];
|
|
SixVector[5]=valArr[5];
|
|
|
|
G4ThreeVector Momentum(valArr[3],valArr[4],valArr[5]);
|
|
|
|
G4double momentum_square= Momentum.mag2();
|
|
fMomentumDir= Momentum.unit();
|
|
|
|
fKineticEnergy = momentum_square /
|
|
(std::sqrt(momentum_square+fRestMass_c2*fRestMass_c2)
|
|
+ fRestMass_c2 );
|
|
// The above equation is stable for small and large momenta
|
|
|
|
// The following components may or may not be
|
|
// integrated over -- integration is optional
|
|
// fKineticEnergy= valArr[6];
|
|
|
|
fLabTimeOfFlight=valArr[7];
|
|
fProperTimeOfFlight=valArr[8];
|
|
fSpin=G4ThreeVector(valArr[9],valArr[10],valArr[11]);
|
|
// fMomentumDir=G4ThreeVector(valArr[13],valArr[14],valArr[15]);
|
|
// fDistanceAlongCurve= valArr[];
|
|
}
|
|
|
|
inline
|
|
G4FieldTrack & G4FieldTrack::operator = ( const G4FieldTrack& rStVec )
|
|
{
|
|
if (&rStVec == this) return *this;
|
|
|
|
SixVector[0]= rStVec.SixVector[0];
|
|
SixVector[1]= rStVec.SixVector[1];
|
|
SixVector[2]= rStVec.SixVector[2];
|
|
SixVector[3]= rStVec.SixVector[3];
|
|
SixVector[4]= rStVec.SixVector[4];
|
|
SixVector[5]= rStVec.SixVector[5];
|
|
SetCurveLength( rStVec.GetCurveLength() );
|
|
|
|
fKineticEnergy= rStVec.fKineticEnergy;
|
|
SetLabTimeOfFlight( rStVec.GetLabTimeOfFlight() );
|
|
SetProperTimeOfFlight( rStVec.GetProperTimeOfFlight() );
|
|
SetSpin( rStVec.GetSpin() );
|
|
// SetMomentumModulus( rStVec.GetMomentumModulus());
|
|
SetMomentumDir( rStVec.fMomentumDir );
|
|
|
|
fChargeState= rStVec.fChargeState;
|
|
// (*fpChargeState)= *(rStVec.fpChargeState);
|
|
// fpChargeState= rStVec.fpChargeState; // Handles!!
|
|
return *this;
|
|
}
|
|
|
|
void
|
|
G4FieldTrack::UpdateFourMomentum( G4double kineticEnergy,
|
|
const G4ThreeVector& momentumDirection )
|
|
{
|
|
G4double momentum_mag = std::sqrt(kineticEnergy*kineticEnergy
|
|
+2.0*fRestMass_c2*kineticEnergy);
|
|
G4ThreeVector momentumVector= momentum_mag * momentumDirection;
|
|
|
|
SetMomentum( momentumVector ); // Also sets direction (from unit)
|
|
fMomentumDir= momentumDirection;
|
|
fKineticEnergy= kineticEnergy;
|
|
}
|
|
|
|
void G4FieldTrack::UpdateState( const G4ThreeVector& position,
|
|
G4double laboratoryTimeOfFlight,
|
|
const G4ThreeVector& momentumDirection,
|
|
G4double kineticEnergy
|
|
)
|
|
{
|
|
// SetCurvePnt( position, momentumVector, s_curve=0.0);
|
|
SetPosition( position);
|
|
fLabTimeOfFlight= laboratoryTimeOfFlight;
|
|
fDistanceAlongCurve= 0.0;
|
|
|
|
UpdateFourMomentum( kineticEnergy, momentumDirection);
|
|
}
|