G4FastStep Class Reference

#include <G4FastStep.hh>

Inheritance 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 &)
Public Member Functions inherited from G4VParticleChange
	G4VParticleChange ()
virtual	~G4VParticleChange ()
G4bool	operator== (const G4VParticleChange &right) const
G4bool	operator!= (const G4VParticleChange &right) const
virtual G4Step *	UpdateStepForAtRest (G4Step *Step)
virtual G4Step *	UpdateStepForAlongStep (G4Step *Step)
virtual G4Step *	UpdateStepForPostStep (G4Step *Step)
virtual void	Initialize (const G4Track &)
G4double	GetTrueStepLength () const
void	ProposeTrueStepLength (G4double truePathLength)
G4double	GetLocalEnergyDeposit () const
void	ProposeLocalEnergyDeposit (G4double anEnergyPart)
G4double	GetNonIonizingEnergyDeposit () const
void	ProposeNonIonizingEnergyDeposit (G4double anEnergyPart)
G4TrackStatus	GetTrackStatus () const
void	ProposeTrackStatus (G4TrackStatus status)
G4SteppingControl	GetSteppingControl () const
void	ProposeSteppingControl (G4SteppingControl StepControlFlag)
G4bool	GetFirstStepInVolume () const
G4bool	GetLastStepInVolume () const
void	ProposeFirstStepInVolume (G4bool flag)
void	ProposeLastStepInVolume (G4bool flag)
void	Clear ()
void	SetNumberOfSecondaries (G4int totSecondaries)
G4int	GetNumberOfSecondaries () const
G4Track *	GetSecondary (G4int anIndex) const
void	AddSecondary (G4Track *aSecondary)
G4double	GetWeight () const
G4double	GetParentWeight () const
void	ProposeWeight (G4double finalWeight)
void	ProposeParentWeight (G4double finalWeight)
void	SetSecondaryWeightByProcess (G4bool)
G4bool	IsSecondaryWeightSetByProcess () const
void	SetParentWeightByProcess (G4bool)
G4bool	IsParentWeightSetByProcess () const
virtual void	DumpInfo () const
void	SetVerboseLevel (G4int vLevel)
G4int	GetVerboseLevel () const
virtual G4bool	CheckIt (const G4Track &)
void	ClearDebugFlag ()
void	SetDebugFlag ()
G4bool	GetDebugFlag () const

Protected Member Functions
	G4FastStep (const G4FastStep &right)
G4FastStep &	operator= (const G4FastStep &right)
Protected Member Functions inherited from G4VParticleChange
	G4VParticleChange (const G4VParticleChange &right)
G4VParticleChange &	operator= (const G4VParticleChange &right)
G4Step *	UpdateStepInfo (G4Step *Step)
void	InitializeTrueStepLength (const G4Track &)
void	InitializeLocalEnergyDeposit (const G4Track &)
void	InitializeSteppingControl (const G4Track &)
void	InitializeParentWeight (const G4Track &)
void	InitializeParentGlobalTime (const G4Track &)
void	InitializeStatusChange (const G4Track &)
void	InitializeSecondaries (const G4Track &)
void	InitializeStepInVolumeFlags (const G4Track &)
G4bool	CheckSecondary (G4Track &)
G4double	GetAccuracyForWarning () const
G4double	GetAccuracyForException () const

Additional Inherited Members
Protected Attributes inherited from G4VParticleChange
G4TrackFastVector *	theListOfSecondaries
G4int	theNumberOfSecondaries
G4int	theSizeOftheListOfSecondaries
G4TrackStatus	theStatusChange
G4SteppingControl	theSteppingControlFlag
G4double	theLocalEnergyDeposit
G4double	theNonIonizingEnergyDeposit
G4double	theTrueStepLength
G4bool	theFirstStepInVolume
G4bool	theLastStepInVolume
G4double	theParentWeight
G4bool	isParentWeightProposed
G4bool	fSetSecondaryWeightByProcess
G4double	theParentGlobalTime
G4int	verboseLevel
G4bool	debugFlag
Static Protected Attributes inherited from G4VParticleChange
static const G4double	accuracyForWarning = 1.0e-9
static const G4double	accuracyForException = 0.001

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 )

virtual

Reimplemented from G4VParticleChange.

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;
}

Referenced by UpdateStepForAtRest(), and UpdateStepForPostStep().

CreateSecondaryTrack() [1/2]

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

Definition at line 223 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;
}

CreateSecondaryTrack() [2/2]

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

Definition at line 201 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);
}

Referenced by CreateSecondaryTrack().

DumpInfo()

void G4FastStep::DumpInfo ( ) const

virtual

Reimplemented from G4VParticleChange.

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;
}

Referenced by CheckIt().

ForceSteppingHitInvocation()

void G4FastStep::ForceSteppingHitInvocation

(

)

GetNumberOfSecondaryTracks()

G4int G4FastStep::GetNumberOfSecondaryTracks

(

)

GetSecondaryTrack()

G4Track * G4FastStep::GetSecondaryTrack

(

G4int

)

GetTotalEnergyDeposited()

G4double G4FastStep::GetTotalEnergyDeposited

(

)

const

Initialize()

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();
}  

Referenced by G4FastSimulationManager::AtRestGetFastSimulationManagerTrigger(), and G4FastSimulationManager::PostStepGetFastSimulationManagerTrigger().

KillPrimaryTrack()

void G4FastStep::KillPrimaryTrack

(

)

Definition at line 87 of file G4FastStep.cc.

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

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 149 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);
}

Referenced by SetPrimaryTrackFinalKineticEnergyAndDirection().

ProposePrimaryTrackFinalMomentumDirection()

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

Definition at line 123 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());
}

Referenced by SetPrimaryTrackFinalMomentum().

ProposePrimaryTrackFinalPolarization()

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

Definition at line 177 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;
}

Referenced by SetPrimaryTrackFinalPolarization().

ProposePrimaryTrackFinalPosition()

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

Definition at line 97 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;
}

Referenced by SetPrimaryTrackFinalPosition().

ProposePrimaryTrackFinalProperTime()

void G4FastStep::ProposePrimaryTrackFinalProperTime

(

G4double

)

ProposePrimaryTrackFinalTime()

void G4FastStep::ProposePrimaryTrackFinalTime

(

G4double

)

ProposePrimaryTrackPathLength()

void G4FastStep::ProposePrimaryTrackPathLength

(

G4double

)

ProposeTotalEnergyDeposited()

void G4FastStep::ProposeTotalEnergyDeposited

(

G4double

anEnergyPart

)

SetNumberOfSecondaryTracks()

void G4FastStep::SetNumberOfSecondaryTracks

(

G4int

)

SetPrimaryTrackFinalEventBiasingWeight()

void G4FastStep::SetPrimaryTrackFinalEventBiasingWeight

(

G4double

)

SetPrimaryTrackFinalKineticEnergy()

void G4FastStep::SetPrimaryTrackFinalKineticEnergy

(

G4double

)

Referenced by KillPrimaryTrack(), and ProposePrimaryTrackFinalKineticEnergyAndDirection().

SetPrimaryTrackFinalKineticEnergyAndDirection()

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

Definition at line 165 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalKineticEnergyAndDirection(kineticEnergy, direction, localCoordinates);
}

SetPrimaryTrackFinalMomentum()

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

Definition at line 138 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalMomentumDirection(momentum, localCoordinates);
}

SetPrimaryTrackFinalPolarization()

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

Definition at line 191 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalPolarization(polarization, localCoordinates);
}

SetPrimaryTrackFinalPosition()

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

Definition at line 112 of file G4FastStep.cc.

{
  ProposePrimaryTrackFinalPosition(position, localCoordinates);
}

SetPrimaryTrackFinalProperTime()

void G4FastStep::SetPrimaryTrackFinalProperTime

(

G4double

)

SetPrimaryTrackFinalTime()

void G4FastStep::SetPrimaryTrackFinalTime

(

G4double

)

SetPrimaryTrackPathLength()

void G4FastStep::SetPrimaryTrackPathLength

(

G4double

)

SetTotalEnergyDeposited()

void G4FastStep::SetTotalEnergyDeposited

(

G4double

anEnergyPart

)

UpdateStepForAtRest()

G4Step * G4FastStep::UpdateStepForAtRest ( G4Step *  Step )

virtual

Reimplemented from G4VParticleChange.

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);
}

UpdateStepForPostStep()

G4Step * G4FastStep::UpdateStepForPostStep ( G4Step *  Step )

virtual

Reimplemented from G4VParticleChange.

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);
}

---

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

• G4FastStep.hh
• G4FastStep.cc