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 &)
Protected Member Functions
	G4FastStep (const G4FastStep &right)
G4FastStep &	operator= (const G4FastStep &right)

---

Detailed Description

Definition at line 91 of file G4FastStep.hh.

---

Constructor & Destructor Documentation

G4FastStep::G4FastStep

(

)

Definition at line 297 of file G4FastStep.cc.

References G4cerr, G4endl, and G4VParticleChange::verboseLevel.

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

G4FastStep::~G4FastStep

(

)

[virtual]

Definition at line 306 of file G4FastStep.cc.

References G4cerr, G4endl, and G4VParticleChange::verboseLevel.

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

G4FastStep::G4FastStep

(

const G4FastStep &

right

)

[protected]

Definition at line 315 of file G4FastStep.cc.

  : G4VParticleChange()
{
   *this = right;
}

---

Member Function Documentation

G4bool G4FastStep::CheckIt

(

const G4Track &

)

[virtual]

Reimplemented from G4VParticleChange.

Definition at line 479 of file G4FastStep.cc.

References G4VParticleChange::CheckIt(), DumpInfo(), FatalException, G4cout, G4endl, G4Exception(), G4VParticleChange::GetAccuracyForException(), G4VParticleChange::GetAccuracyForWarning(), G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4Track::GetProperTime(), JustWarning, and ns.

Referenced by UpdateStepForAtRest(), and UpdateStepForPostStep().

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

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

Definition at line 224 of file G4FastStep.cc.

References G4VParticleChange::AddSecondary(), G4FastTrack::GetInverseAffineTransformation(), G4DynamicParticle::GetPolarization(), G4DynamicParticle::SetMomentumDirection(), and G4DynamicParticle::SetPolarization().

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

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

Definition at line 202 of file G4FastStep.cc.

References G4DynamicParticle::SetPolarization().

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

void G4FastStep::DumpInfo

(

)

const [virtual]

Reimplemented from G4VParticleChange.

Definition at line 435 of file G4FastStep.cc.

References G4VParticleChange::DumpInfo(), G4cout, G4endl, and ns.

Referenced by CheckIt().

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

void G4FastStep::ForceSteppingHitInvocation

(

)

[inline]

Definition at line 123 of file G4FastStep.icc.

References NormalCondition, and G4VParticleChange::ProposeSteppingControl().

{
  ProposeSteppingControl(NormalCondition);
}

G4int G4FastStep::GetNumberOfSecondaryTracks

(

)

[inline]

Definition at line 93 of file G4FastStep.icc.

References G4VParticleChange::GetNumberOfSecondaries().

{
  return GetNumberOfSecondaries();
}

G4Track * G4FastStep::GetSecondaryTrack

(

G4int

)

[inline]

Definition at line 98 of file G4FastStep.icc.

References G4VParticleChange::GetSecondary().

{
  return GetSecondary(i);
}

G4double G4FastStep::GetTotalEnergyDeposited

(

)

const [inline]

Definition at line 117 of file G4FastStep.icc.

References G4VParticleChange::GetLocalEnergyDeposit().

{
  return GetLocalEnergyDeposit();
}

void G4FastStep::Initialize

(

const G4FastTrack &

)

Definition at line 53 of file G4FastStep.cc.

References AvoidHitInvocation, G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMomentumDirection(), G4DynamicParticle::GetPolarization(), G4Track::GetPosition(), G4FastTrack::GetPrimaryTrack(), G4DynamicParticle::GetProperTime(), G4Track::GetWeight(), G4VParticleChange::Initialize(), and G4VParticleChange::theSteppingControlFlag.

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

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

void G4FastStep::KillPrimaryTrack

(

)

Definition at line 87 of file G4FastStep.cc.

References fStopAndKill, G4VParticleChange::ProposeTrackStatus(), and SetPrimaryTrackFinalKineticEnergy().

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

G4bool G4FastStep::operator!=

(

const G4FastStep &

right

)

const

Definition at line 353 of file G4FastStep.cc.

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

G4FastStep & G4FastStep::operator=

(

const G4FastStep &

right

)

[protected]

Definition at line 322 of file G4FastStep.cc.

References G4VParticleChange::operator=(), G4VParticleChange::theListOfSecondaries, G4VParticleChange::theLocalEnergyDeposit, G4VParticleChange::theNumberOfSecondaries, G4VParticleChange::theSizeOftheListOfSecondaries, G4VParticleChange::theStatusChange, G4VParticleChange::theSteppingControlFlag, and G4VParticleChange::theTrueStepLength.

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

G4bool G4FastStep::operator==

(

const G4FastStep &

right

)

const

Definition at line 348 of file G4FastStep.cc.

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

void G4FastStep::ProposePrimaryTrackFinalEventBiasingWeight

(

G4double

)

[inline]

Definition at line 148 of file G4FastStep.icc.

Referenced by SetPrimaryTrackFinalEventBiasingWeight().

{
  theWeightChange = w;
}

void G4FastStep::ProposePrimaryTrackFinalKineticEnergy

(

G4double

)

[inline]

Definition at line 57 of file G4FastStep.icc.

Referenced by SetPrimaryTrackFinalKineticEnergy().

{
  theEnergyChange = kineticEnergy;
}

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

Definition at line 150 of file G4FastStep.cc.

References G4FastTrack::GetInverseAffineTransformation(), and SetPrimaryTrackFinalKineticEnergy().

Referenced by SetPrimaryTrackFinalKineticEnergyAndDirection().

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

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

Definition at line 124 of file G4FastStep.cc.

References G4FastTrack::GetInverseAffineTransformation().

Referenced by SetPrimaryTrackFinalMomentum().

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

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

Definition at line 178 of file G4FastStep.cc.

References G4FastTrack::GetInverseAffineTransformation().

Referenced by SetPrimaryTrackFinalPolarization().

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

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

Definition at line 98 of file G4FastStep.cc.

References G4FastTrack::GetInverseAffineTransformation().

Referenced by SetPrimaryTrackFinalPosition().

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

void G4FastStep::ProposePrimaryTrackFinalProperTime

(

G4double

)

[inline]

Definition at line 44 of file G4FastStep.icc.

Referenced by SetPrimaryTrackFinalProperTime().

{
  theProperTimeChange = properTime;
}

void G4FastStep::ProposePrimaryTrackFinalTime

(

G4double

)

[inline]

Definition at line 32 of file G4FastStep.icc.

Referenced by SetPrimaryTrackFinalTime().

{
  theTimeChange = time;
}

void G4FastStep::ProposePrimaryTrackPathLength

(

G4double

)

[inline]

Definition at line 70 of file G4FastStep.icc.

References G4VParticleChange::ProposeTrueStepLength().

Referenced by SetPrimaryTrackPathLength().

{
  ProposeTrueStepLength(pathLength);
}

void G4FastStep::ProposeTotalEnergyDeposited

(

G4double

anEnergyPart

)

[inline]

Definition at line 107 of file G4FastStep.icc.

References G4VParticleChange::ProposeLocalEnergyDeposit().

Referenced by SetTotalEnergyDeposited().

{
  ProposeLocalEnergyDeposit(anEnergyPart);
}

void G4FastStep::SetNumberOfSecondaryTracks

(

G4int

)

[inline]

Definition at line 87 of file G4FastStep.icc.

References G4VParticleChange::SetNumberOfSecondaries().

{
  SetNumberOfSecondaries(nSecondaries);
}

void G4FastStep::SetPrimaryTrackFinalEventBiasingWeight

(

G4double

)

[inline]

Definition at line 153 of file G4FastStep.icc.

References ProposePrimaryTrackFinalEventBiasingWeight().

{
  ProposePrimaryTrackFinalEventBiasingWeight(w);
}

void G4FastStep::SetPrimaryTrackFinalKineticEnergy

(

G4double

)

[inline]

Definition at line 63 of file G4FastStep.icc.

References ProposePrimaryTrackFinalKineticEnergy().

Referenced by KillPrimaryTrack(), and ProposePrimaryTrackFinalKineticEnergyAndDirection().

{
  ProposePrimaryTrackFinalKineticEnergy(kineticEnergy);
}

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

Definition at line 166 of file G4FastStep.cc.

References ProposePrimaryTrackFinalKineticEnergyAndDirection().

{
  ProposePrimaryTrackFinalKineticEnergyAndDirection(kineticEnergy, direction, localCoordinates);
}

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

Definition at line 139 of file G4FastStep.cc.

References ProposePrimaryTrackFinalMomentumDirection().

{
  ProposePrimaryTrackFinalMomentumDirection(momentum, localCoordinates);
}

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

Definition at line 192 of file G4FastStep.cc.

References ProposePrimaryTrackFinalPolarization().

{
  ProposePrimaryTrackFinalPolarization(polarization, localCoordinates);
}

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

Definition at line 113 of file G4FastStep.cc.

References ProposePrimaryTrackFinalPosition().

{
  ProposePrimaryTrackFinalPosition(position, localCoordinates);
}

void G4FastStep::SetPrimaryTrackFinalProperTime

(

G4double

)

[inline]

Definition at line 49 of file G4FastStep.icc.

References ProposePrimaryTrackFinalProperTime().

{
  ProposePrimaryTrackFinalProperTime(properTime);
}

void G4FastStep::SetPrimaryTrackFinalTime

(

G4double

)

[inline]

Definition at line 37 of file G4FastStep.icc.

References ProposePrimaryTrackFinalTime().

{
  ProposePrimaryTrackFinalTime(time);
}

void G4FastStep::SetPrimaryTrackPathLength

(

G4double

)

[inline]

Definition at line 75 of file G4FastStep.icc.

References ProposePrimaryTrackPathLength().

{
  ProposePrimaryTrackPathLength(pathLength);
}

void G4FastStep::SetTotalEnergyDeposited

(

G4double

anEnergyPart

)

[inline]

Definition at line 111 of file G4FastStep.icc.

References ProposeTotalEnergyDeposited().

{
  ProposeTotalEnergyDeposited(anEnergyPart);
}

G4Step * G4FastStep::UpdateStepForAtRest

(

G4Step *

Step

)

[virtual]

Reimplemented from G4VParticleChange.

Definition at line 399 of file G4FastStep.cc.

References G4StepPoint::AddLocalTime(), CheckIt(), G4VParticleChange::debugFlag, G4Track::GetGlobalTime(), G4Step::GetPostStepPoint(), G4Step::GetTrack(), G4StepPoint::SetGlobalTime(), G4StepPoint::SetKineticEnergy(), G4StepPoint::SetMomentumDirection(), G4StepPoint::SetPolarization(), G4StepPoint::SetPosition(), G4StepPoint::SetProperTime(), G4StepPoint::SetWeight(), and G4VParticleChange::UpdateStepInfo().

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

G4Step * G4FastStep::UpdateStepForPostStep

(

G4Step *

Step

)

[virtual]

Reimplemented from G4VParticleChange.

Definition at line 362 of file G4FastStep.cc.

References G4StepPoint::AddLocalTime(), CheckIt(), G4VParticleChange::debugFlag, G4Track::GetGlobalTime(), G4Step::GetPostStepPoint(), G4Step::GetTrack(), G4StepPoint::SetGlobalTime(), G4StepPoint::SetKineticEnergy(), G4StepPoint::SetMomentumDirection(), G4StepPoint::SetPolarization(), G4StepPoint::SetPosition(), G4StepPoint::SetProperTime(), G4StepPoint::SetWeight(), and G4VParticleChange::UpdateStepInfo().

{ 
  // 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.icc
• G4FastStep.cc

---