G4FastStep Class Reference

#include <G4FastStep.hh>

Inheritance diagram for G4FastStep:

Collaboration diagram for G4FastStep:

Public Member Functions
void	KillPrimaryTrack ()
void	ProposePrimaryTrackFinalPosition (const G4ThreeVector &, G4bool localCoordinates=true)
void	SetPrimaryTrackFinalPosition (const G4ThreeVector &, G4bool localCoordinates=true)
void	ProposePrimaryTrackFinalTime (G4double)
void	SetPrimaryTrackFinalTime (G4double)
void	ProposePrimaryTrackFinalProperTime (G4double)
void	SetPrimaryTrackFinalProperTime (G4double)
void	ProposePrimaryTrackFinalMomentumDirection (const G4ThreeVector &, G4bool localCoordinates=true)
void	SetPrimaryTrackFinalMomentum (const G4ThreeVector &, G4bool localCoordinates=true)
void	ProposePrimaryTrackFinalKineticEnergy (G4double)
void	SetPrimaryTrackFinalKineticEnergy (G4double)
void	ProposePrimaryTrackFinalKineticEnergyAndDirection (G4double, const G4ThreeVector &, G4bool localCoordinates=true)
void	SetPrimaryTrackFinalKineticEnergyAndDirection (G4double, const G4ThreeVector &, G4bool localCoordinates=true)
void	ProposePrimaryTrackFinalPolarization (const G4ThreeVector &, G4bool localCoordinates=true)
void	SetPrimaryTrackFinalPolarization (const G4ThreeVector &, G4bool localCoordinates=true)
void	ProposePrimaryTrackPathLength (G4double)
void	SetPrimaryTrackPathLength (G4double)
void	ProposePrimaryTrackFinalEventBiasingWeight (G4double)
void	SetPrimaryTrackFinalEventBiasingWeight (G4double)
void	SetNumberOfSecondaryTracks (G4int)
G4int	GetNumberOfSecondaryTracks ()
G4Track *	CreateSecondaryTrack (const G4DynamicParticle &, G4ThreeVector, G4ThreeVector, G4double, G4bool localCoordinates=true)
G4Track *	CreateSecondaryTrack (const G4DynamicParticle &, G4ThreeVector, G4double, G4bool localCoordinates=true)
G4Track *	GetSecondaryTrack (G4int)
void	ProposeTotalEnergyDeposited (G4double anEnergyPart)
void	SetTotalEnergyDeposited (G4double anEnergyPart)
G4double	GetTotalEnergyDeposited () const
void	ForceSteppingHitInvocation ()
	G4FastStep ()
virtual	~G4FastStep ()
G4bool	operator== (const G4FastStep &right) const
G4bool	operator!= (const G4FastStep &right) const
G4Step *	UpdateStepForAtRest (G4Step *Step)
G4Step *	UpdateStepForPostStep (G4Step *Step)
void	Initialize (const G4FastTrack &)
void	DumpInfo () const
G4bool	CheckIt (const G4Track &)

Protected Member Functions
	G4FastStep (const G4FastStep &right)
G4FastStep &	operator= (const G4FastStep &right)

Private Member Functions
void	Initialize (const G4Track &)
void	SetMomentumChange (G4double Px, G4double Py, G4double Pz)
void	SetMomentumChange (const G4ThreeVector &Pfinal)

Private Attributes
G4ParticleMomentum	theMomentumChange
G4ThreeVector	thePolarizationChange
G4double	theEnergyChange
G4ThreeVector	thePositionChange
G4double	theTimeChange
G4double	theProperTimeChange
const G4FastTrack *	fFastTrack
G4double	theWeightChange

Detailed Description

Definition at line 91 of file G4FastStep.hh.

Constructor & Destructor Documentation

G4FastStep() [1/2]

G4FastStep::G4FastStep

(

)

Definition at line 297 of file G4FastStep.cc.

  : G4VParticleChange()
{
  if (verboseLevel>2)
  {
    G4cerr << "G4FastStep::G4FastStep() " << G4endl;
  }
}

~G4FastStep()

G4FastStep::~G4FastStep ( )

virtual

Definition at line 306 of file G4FastStep.cc.

{
  if (verboseLevel>2)
  {
    G4cerr << "G4FastStep::~G4FastStep() " << G4endl;
  }
}

G4FastStep() [2/2]

G4FastStep::G4FastStep ( const G4FastStep &  right )

protected

Definition at line 315 of file G4FastStep.cc.

  : G4VParticleChange()
{
   *this = right;
}

Member Function Documentation

CheckIt()

G4bool G4FastStep::CheckIt

(

const G4Track &

aTrack

)

Definition at line 479 of file G4FastStep.cc.

{
  //
  //      In the G4FastStep::CheckIt
  //      We only check a bit
  //      
  //      If the user violates the energy,
  //      We don't care, we agree.
  //
  //      But for theMomentumDirectionChange,
  //      We do pay attention.
  //      And if too large is its range,
  //      We issue an Exception.
  //
  //
  // It means, the G4FastStep::CheckIt issues an exception only for the
  // theMomentumDirectionChange which should be an unit vector
  // and it corrects it because it could cause problems for the ulterior
  // tracking.For the rest, only warning are issued.

  G4bool    itsOK = true;
  G4bool    exitWithError = false;
  G4double  accuracy;
  
  // Energy should not be larger than the initial value
  accuracy = ( theEnergyChange - aTrack.GetKineticEnergy())/MeV;
  if (accuracy > GetAccuracyForWarning())
    {
      G4ExceptionDescription ed;
      ed << "The energy becomes larger than the initial value, difference = " <<  accuracy << " MeV" << G4endl;
      G4Exception("G4FastStep::CheckIt(const G4Track& aTrack)",
          "FastSim006",
          JustWarning, ed);
      itsOK = false;
      if (accuracy > GetAccuracyForException())  {exitWithError = true;}
    }
  
  G4bool itsOKforMomentum = true;
  if ( theEnergyChange >0.)
    {
      accuracy = std::abs(theMomentumChange.mag2()-1.0);
      if (accuracy > GetAccuracyForWarning())
    {
      G4ExceptionDescription ed;
      ed << "The Momentum Change is not a unit vector, difference = " <<  accuracy << G4endl;
      G4Exception("G4FastStep::CheckIt(const G4Track& aTrack)",
              "FastSim007",
              JustWarning, ed);
      itsOK = itsOKforMomentum = false;
      if (accuracy > GetAccuracyForException())  {exitWithError = true;}
    }
    }
  
  accuracy = (aTrack.GetGlobalTime()- theTimeChange)/ns;  
  if (accuracy > GetAccuracyForWarning())
    {
      G4ExceptionDescription ed;
      ed << "The global time is getting backward, difference = " <<  accuracy << " ns" << G4endl;
      G4Exception("G4FastStep::CheckIt(const G4Track& aTrack)",
          "FastSim008",
          JustWarning, ed);
      itsOK = false;
    }
  
  accuracy = (aTrack.GetProperTime() - theProperTimeChange )/ns;
  if (accuracy >  GetAccuracyForWarning())
    {
      G4ExceptionDescription ed;
      ed << "The proper time is getting backward, difference = " <<  accuracy << " ns" << G4endl;
      G4Exception("G4FastStep::CheckIt(const G4Track& aTrack)",
          "FastSim009",
          JustWarning, ed);
      itsOK = false;
    }
  
  if (!itsOK)
    { 
      G4cout << "ERROR - G4FastStep::CheckIt() " << G4endl;
      G4cout << "        Pointer : " << this << G4endl ;
      DumpInfo();
    }
  
  // Exit with error
  if (exitWithError)
    {
      G4ExceptionDescription ed;
      ed << "An inaccuracy in G4FastStep is beyond tolerance." << G4endl;
      G4Exception("G4FastStep::CheckIt(const G4Track& aTrack)",
          "FastSim010",
          FatalException, ed);
    }
  
  //correction for Momentum only.
  if (!itsOKforMomentum) {
    G4double vmag = theMomentumChange.mag();
    theMomentumChange = (1./vmag)*theMomentumChange;
  }
  
  itsOK = (itsOK) && G4VParticleChange::CheckIt(aTrack); 
  return itsOK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSecondaryTrack() [1/2]

G4Track * G4FastStep::CreateSecondaryTrack	(	const G4DynamicParticle &	dynamics,
		G4ThreeVector	polarization,
		G4ThreeVector	position,
		G4double	time,
		G4bool	localCoordinates = true
	)

Definition at line 202 of file G4FastStep.cc.

{
  G4DynamicParticle dummyDynamics(dynamics);
  
  // ------------------------------------------
  // Add the polarization to the dummyDynamics:
  // ------------------------------------------
  dummyDynamics.SetPolarization(polarization.x(),
                                polarization.y(),
                                polarization.z());
  
  return CreateSecondaryTrack(dummyDynamics, position, time, localCoordinates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSecondaryTrack() [2/2]

G4Track * G4FastStep::CreateSecondaryTrack	(	const G4DynamicParticle &	dynamics,
		G4ThreeVector	position,
		G4double	time,
		G4bool	localCoordinates = true
	)

Definition at line 224 of file G4FastStep.cc.

{
  // ----------------------------------------
  // Quantities in global coordinates system.
  //  
  // The allocated globalDynamics is deleted
  // by the destructor of the G4Track.
  // ----------------------------------------
  G4DynamicParticle* globalDynamics =
    new G4DynamicParticle(dynamics);
  G4ThreeVector globalPosition(position);
  
  // -----------------------------------
  // Convert to global system if needed:
  // -----------------------------------
  if (localCoordinates)
    {
      // -- Momentum Direction:
      globalDynamics->SetMomentumDirection(fFastTrack->
                                           GetInverseAffineTransformation()->
                                           TransformAxis(globalDynamics->
                                                         GetMomentumDirection()));
      // -- Polarization:
      G4ThreeVector globalPolarization;
      globalPolarization = fFastTrack->GetInverseAffineTransformation()->
        TransformAxis(globalDynamics->GetPolarization());
      globalDynamics->SetPolarization(
                                      globalPolarization.x(),
                                      globalPolarization.y(),
                                      globalPolarization.z()
                                      );
      
      // -- Position:
      globalPosition = fFastTrack->GetInverseAffineTransformation()->
        TransformPoint(globalPosition);
    }
  
  //-------------------------------------
  // Create the G4Track of the secondary:
  //-------------------------------------
  G4Track* secondary = new G4Track(
                                   globalDynamics,
                                   time,
                                   globalPosition
                                   );
  
  //-------------------------------
  // and feed the changes:
  //-------------------------------
  AddSecondary(secondary);
  
  //--------------------------------------
  // returns the pointer on the secondary:
  //--------------------------------------
  return secondary;
}

Here is the call graph for this function:

DumpInfo()

void G4FastStep::DumpInfo

(

)

const

Definition at line 435 of file G4FastStep.cc.

{
// use base-class DumpInfo
  G4VParticleChange::DumpInfo();

  G4cout.precision(3);
  G4cout << "        Position - x (mm)   : " 
       << std::setw(20) << thePositionChange.x()/mm
       << G4endl; 
  G4cout << "        Position - y (mm)   : " 
       << std::setw(20) << thePositionChange.y()/mm
       << G4endl; 
  G4cout << "        Position - z (mm)   : " 
       << std::setw(20) << thePositionChange.z()/mm
       << G4endl;
  G4cout << "        Time (ns)           : " 
       << std::setw(20) << theTimeChange/ns
       << G4endl;
  G4cout << "        Proper Time (ns)    : " 
       << std::setw(20) << theProperTimeChange/ns
       << G4endl;
  G4cout << "        Momentum Direct - x : " 
       << std::setw(20) << theMomentumChange.x()
       << G4endl;
  G4cout << "        Momentum Direct - y : " 
       << std::setw(20) << theMomentumChange.y()
       << G4endl;
  G4cout << "        Momentum Direct - z : " 
       << std::setw(20) << theMomentumChange.z()
       << G4endl;
  G4cout << "        Kinetic Energy (MeV): " 
       << std::setw(20) << theEnergyChange/MeV
       << G4endl;
  G4cout << "        Polarization - x    : " 
       << std::setw(20) << thePolarizationChange.x()
       << G4endl;
  G4cout << "        Polarization - y    : " 
       << std::setw(20) << thePolarizationChange.y()
       << G4endl;
  G4cout << "        Polarization - z    : " 
       << std::setw(20) <<  thePolarizationChange.z()
       << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ForceSteppingHitInvocation()

void G4FastStep::ForceSteppingHitInvocation

(

)

GetNumberOfSecondaryTracks()

G4int G4FastStep::GetNumberOfSecondaryTracks

(

)

GetSecondaryTrack()

G4Track* G4FastStep::GetSecondaryTrack

(

G4int

)

GetTotalEnergyDeposited()

G4double G4FastStep::GetTotalEnergyDeposited

(

)

const

Initialize() [1/2]

void G4FastStep::Initialize

(

const G4FastTrack &

fastTrack

)

Definition at line 53 of file G4FastStep.cc.

{
  // keeps the fastTrack reference
  fFastTrack=&fastTrack;

  // currentTrack will be used to Initialize the other data members
  const G4Track& currentTrack = *(fFastTrack->GetPrimaryTrack());

  // use base class's method at first
  G4VParticleChange::Initialize(currentTrack);

  // set Energy/Momentum etc. equal to those of the parent particle
  const G4DynamicParticle*  pParticle = currentTrack.GetDynamicParticle();
  theEnergyChange          = pParticle->GetKineticEnergy();
  theMomentumChange        = pParticle->GetMomentumDirection();
  thePolarizationChange    = pParticle->GetPolarization();
  theProperTimeChange      = pParticle->GetProperTime();

  // set Position/Time etc. equal to those of the parent track
  thePositionChange      = currentTrack.GetPosition();
  theTimeChange          = currentTrack.GetGlobalTime();

  // switch off stepping hit invokation by default:
  theSteppingControlFlag = AvoidHitInvocation;

  // event biasing weigth:
  theWeightChange        = currentTrack.GetWeight();
}  

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize() [2/2]

void G4FastStep::Initialize ( const G4Track &  )

private

Definition at line 286 of file G4FastStep.cc.

{
  G4ExceptionDescription  tellWhatIsWrong;
  tellWhatIsWrong << "G4FastStep can be initialised only through G4FastTrack."
          << G4endl;
  G4Exception("G4FastStep::Initialize(const G4Track&)",
          "FastSim005",
          FatalException,
          tellWhatIsWrong);
}

Here is the call graph for this function:

KillPrimaryTrack()

void G4FastStep::KillPrimaryTrack

(

)

Definition at line 87 of file G4FastStep.cc.

{
  SetPrimaryTrackFinalKineticEnergy(0.) ;
  ProposeTrackStatus(fStopAndKill) ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

G4bool G4FastStep::operator!=

(

const G4FastStep &

right

)

const

Definition at line 353 of file G4FastStep.cc.

{
   return ((G4VParticleChange *)this != (G4VParticleChange *) &right);
}

operator=()

G4FastStep & G4FastStep::operator= ( const G4FastStep &  right )

protected

Definition at line 322 of file G4FastStep.cc.

{
   if (this != &right)
   {
     G4VParticleChange::operator=(right);
     theListOfSecondaries          = right.theListOfSecondaries;
     theSizeOftheListOfSecondaries = right.theSizeOftheListOfSecondaries;
     theNumberOfSecondaries        = right.theNumberOfSecondaries;
     theStatusChange               = right.theStatusChange;
     theMomentumChange             = right.theMomentumChange;
     thePolarizationChange         = right.thePolarizationChange;
     thePositionChange             = right.thePositionChange;
     theTimeChange                 = right.theTimeChange;
     theEnergyChange               = right.theEnergyChange;
     theTrueStepLength             = right.theTrueStepLength;
     theLocalEnergyDeposit         = right.theLocalEnergyDeposit;
     theSteppingControlFlag        = right.theSteppingControlFlag;
     theWeightChange               = right.theWeightChange;
   }
   return *this;
}

operator==()

G4bool G4FastStep::operator==

(

const G4FastStep &

right

)

const

Definition at line 348 of file G4FastStep.cc.

{
   return ((G4VParticleChange *)this == (G4VParticleChange *) &right);
}

ProposePrimaryTrackFinalEventBiasingWeight()

void G4FastStep::ProposePrimaryTrackFinalEventBiasingWeight

(

G4double

)

ProposePrimaryTrackFinalKineticEnergy()

void G4FastStep::ProposePrimaryTrackFinalKineticEnergy

(

G4double

)

ProposePrimaryTrackFinalKineticEnergyAndDirection()

void G4FastStep::ProposePrimaryTrackFinalKineticEnergyAndDirection	(	G4double	kineticEnergy,
		const G4ThreeVector &	direction,
		G4bool	localCoordinates = true
	)

Definition at line 150 of file G4FastStep.cc.

{
  // Compute global direction if needed...
  G4ThreeVector globalDirection = direction;
  if (localCoordinates)
    globalDirection =fFastTrack->GetInverseAffineTransformation()-> 
      TransformAxis(direction);
  // ...and feed the globalMomentum (ensuring unitarity)
  SetMomentumChange(globalDirection.unit());
  SetPrimaryTrackFinalKineticEnergy(kineticEnergy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProposePrimaryTrackFinalMomentumDirection()

void G4FastStep::ProposePrimaryTrackFinalMomentumDirection	(	const G4ThreeVector &	momentum,
		G4bool	localCoordinates = true
	)

Definition at line 124 of file G4FastStep.cc.

{
  // Compute the momentum in global reference
  // system if needed ...
  G4ThreeVector globalMomentum = momentum;
  if (localCoordinates)
    globalMomentum = fFastTrack->GetInverseAffineTransformation()->
      TransformAxis(momentum);
  // ...and feed the globalMomentum (ensuring unitarity)
  SetMomentumChange(globalMomentum.unit());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProposePrimaryTrackFinalPolarization()

void G4FastStep::ProposePrimaryTrackFinalPolarization	(	const G4ThreeVector &	polarization,
		G4bool	localCoordinates = true
	)

Definition at line 178 of file G4FastStep.cc.

{
  // Compute polarization in global system if needed:
  G4ThreeVector globalPolarization(polarization);
  if (localCoordinates)
    globalPolarization = fFastTrack->GetInverseAffineTransformation()->
      TransformAxis(globalPolarization);  
  // Feed the particle globalPolarization:
  thePolarizationChange = globalPolarization;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProposePrimaryTrackFinalPosition()

void G4FastStep::ProposePrimaryTrackFinalPosition	(	const G4ThreeVector &	position,
		G4bool	localCoordinates = true
	)

Definition at line 98 of file G4FastStep.cc.

{
  // Compute the position coordinate in global
  // reference system if needed ...
  G4ThreeVector globalPosition = position;
  if (localCoordinates) 
    globalPosition = fFastTrack->GetInverseAffineTransformation()->
      TransformPoint(position);
  // ...and feed the globalPosition:
  thePositionChange = globalPosition;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProposePrimaryTrackFinalProperTime()

void G4FastStep::ProposePrimaryTrackFinalProperTime

(

G4double

)

ProposePrimaryTrackFinalTime()

void G4FastStep::ProposePrimaryTrackFinalTime

(

G4double

)

ProposePrimaryTrackPathLength()

void G4FastStep::ProposePrimaryTrackPathLength

(

G4double

)

Here is the caller graph for this function:

ProposeTotalEnergyDeposited()

void G4FastStep::ProposeTotalEnergyDeposited

(

G4double

anEnergyPart

)

Here is the caller graph for this function:

SetMomentumChange() [1/2]

void G4FastStep::SetMomentumChange ( G4double  Px, G4double  Py, G4double  Pz  )

private

Here is the caller graph for this function:

SetMomentumChange() [2/2]

void G4FastStep::SetMomentumChange ( const G4ThreeVector &  Pfinal )

private

SetNumberOfSecondaryTracks()

void G4FastStep::SetNumberOfSecondaryTracks

(

G4int

)

Here is the caller graph for this function:

SetPrimaryTrackFinalEventBiasingWeight()

void G4FastStep::SetPrimaryTrackFinalEventBiasingWeight

(

G4double

)

SetPrimaryTrackFinalKineticEnergy()

void G4FastStep::SetPrimaryTrackFinalKineticEnergy

(

G4double

)

Here is the caller graph for this function:

SetPrimaryTrackFinalKineticEnergyAndDirection()

void G4FastStep::SetPrimaryTrackFinalKineticEnergyAndDirection	(	G4double	kineticEnergy,
		const G4ThreeVector &	direction,
		G4bool	localCoordinates = true
	)

Definition at line 166 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalKineticEnergyAndDirection(kineticEnergy, direction, localCoordinates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetPrimaryTrackFinalMomentum()

void G4FastStep::SetPrimaryTrackFinalMomentum	(	const G4ThreeVector &	momentum,
		G4bool	localCoordinates = true
	)

Definition at line 139 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalMomentumDirection(momentum, localCoordinates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetPrimaryTrackFinalPolarization()

void G4FastStep::SetPrimaryTrackFinalPolarization	(	const G4ThreeVector &	polarization,
		G4bool	localCoordinates = true
	)

Definition at line 192 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalPolarization(polarization, localCoordinates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetPrimaryTrackFinalPosition()

void G4FastStep::SetPrimaryTrackFinalPosition	(	const G4ThreeVector &	position,
		G4bool	localCoordinates = true
	)

Definition at line 113 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalPosition(position, localCoordinates);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetPrimaryTrackFinalProperTime()

void G4FastStep::SetPrimaryTrackFinalProperTime

(

G4double

)

SetPrimaryTrackFinalTime()

void G4FastStep::SetPrimaryTrackFinalTime

(

G4double

)

SetPrimaryTrackPathLength()

void G4FastStep::SetPrimaryTrackPathLength

(

G4double

)

Here is the caller graph for this function:

SetTotalEnergyDeposited()

void G4FastStep::SetTotalEnergyDeposited

(

G4double

anEnergyPart

)

Here is the caller graph for this function:

UpdateStepForAtRest()

G4Step * G4FastStep::UpdateStepForAtRest

(

G4Step *

Step

)

Definition at line 399 of file G4FastStep.cc.

{ 
  // A physics process always calculates the final state of the particle

  // G4StepPoint* pPreStepPoint  = pStep->GetPreStepPoint(); 
  G4StepPoint* pPostStepPoint = pStep->GetPostStepPoint(); 
  G4Track*     aTrack  = pStep->GetTrack();
  // G4double     mass = aTrack->GetDynamicParticle()->GetMass();
 
  // update kinetic energy and momentum direction
  pPostStepPoint->SetMomentumDirection(theMomentumChange);
  pPostStepPoint->SetKineticEnergy( theEnergyChange );

  // update polarization
  pPostStepPoint->SetPolarization( thePolarizationChange );
      
  // update position and time
  pPostStepPoint->SetPosition( thePositionChange  );
  pPostStepPoint->SetGlobalTime( theTimeChange  );
  pPostStepPoint->AddLocalTime( theTimeChange 
                                 - aTrack->GetGlobalTime());
  pPostStepPoint->SetProperTime( theProperTimeChange  );

  // update weight
  pPostStepPoint->SetWeight( theWeightChange );

  if (debugFlag) CheckIt(*aTrack);

  //  Update the G4Step specific attributes 
  return UpdateStepInfo(pStep);
}

Here is the call graph for this function:

UpdateStepForPostStep()

G4Step * G4FastStep::UpdateStepForPostStep

(

G4Step *

Step

)

Definition at line 362 of file G4FastStep.cc.

{ 
  // A physics process always calculates the final state of the particle

  // Take note that the return type of GetMomentumChange is a
  // pointer to G4ParticleMometum. Also it is a normalized 
  // momentum vector.

  //  G4StepPoint* pPreStepPoint  = pStep->GetPreStepPoint(); 
  G4StepPoint* pPostStepPoint = pStep->GetPostStepPoint(); 
  G4Track*     aTrack  = pStep->GetTrack();
  //  G4double     mass = aTrack->GetDynamicParticle()->GetMass();
 
  // update kinetic energy and momentum direction
  pPostStepPoint->SetMomentumDirection(theMomentumChange);
  pPostStepPoint->SetKineticEnergy( theEnergyChange );

   // update polarization
  pPostStepPoint->SetPolarization( thePolarizationChange );
      
  // update position and time
  pPostStepPoint->SetPosition( thePositionChange  );
  pPostStepPoint->SetGlobalTime( theTimeChange  );
  pPostStepPoint->AddLocalTime( theTimeChange 
                                 - aTrack->GetGlobalTime());
  pPostStepPoint->SetProperTime( theProperTimeChange  );

  // update weight
  pPostStepPoint->SetWeight( theWeightChange );

  if (debugFlag) CheckIt(*aTrack);

  
  //  Update the G4Step specific attributes 
  return UpdateStepInfo(pStep);
}

Here is the call graph for this function:

Member Data Documentation

fFastTrack

const G4FastTrack* G4FastStep::fFastTrack

private

Definition at line 366 of file G4FastStep.hh.

theEnergyChange

G4double G4FastStep::theEnergyChange

private

Definition at line 354 of file G4FastStep.hh.

theMomentumChange

G4ParticleMomentum G4FastStep::theMomentumChange

private

Definition at line 348 of file G4FastStep.hh.

thePolarizationChange

G4ThreeVector G4FastStep::thePolarizationChange

private

Definition at line 351 of file G4FastStep.hh.

thePositionChange

G4ThreeVector G4FastStep::thePositionChange

private

Definition at line 357 of file G4FastStep.hh.

theProperTimeChange

G4double G4FastStep::theProperTimeChange

private

Definition at line 363 of file G4FastStep.hh.

theTimeChange

G4double G4FastStep::theTimeChange

private

Definition at line 360 of file G4FastStep.hh.

theWeightChange

G4double G4FastStep::theWeightChange

private

Definition at line 369 of file G4FastStep.hh.

---

The documentation for this class was generated from the following files:

• G4FastStep.hh
• G4FastStep.cc