G4ErrorPropagator Class Reference

#include <G4ErrorPropagator.hh>

Public Member Functions
	G4ErrorPropagator ()
	~G4ErrorPropagator ()
G4Track *	InitG4Track (G4ErrorTrajState &initialTS)
G4int	Propagate (G4ErrorTrajState *currentTS, const G4ErrorTarget *target, G4ErrorMode mode=G4ErrorMode_PropForwards)
G4int	PropagateOneStep (G4ErrorTrajState *currentTS)
G4int	MakeOneStep (G4ErrorFreeTrajState *currentTS_FREE)
G4ErrorFreeTrajState *	InitFreeTrajState (G4ErrorTrajState *currentTS)
void	GetFinalTrajState (G4ErrorTrajState *currentTS, G4ErrorFreeTrajState *currentTS_FREE, const G4ErrorTarget *target)
void	InvokePreUserTrackingAction (G4Track *fpTrack)
void	InvokePostUserTrackingAction (G4Track *fpTrack)
G4bool	CheckIfLastStep (G4Track *aTrack)
const G4ErrorTrajState *	GetInitialTrajState () const
G4double	GetStepLength () const
void	SetStepLength (const G4double sl)
void	SetStepN (const G4int sn)

Detailed Description

Definition at line 53 of file G4ErrorPropagator.hh.

Constructor & Destructor Documentation

G4ErrorPropagator()

G4ErrorPropagator::G4ErrorPropagator

(

)

Definition at line 55 of file G4ErrorPropagator.cc.

  : theStepLength(0.)
  , theInitialTrajState(0)
  , theStepN(0)
  , theG4Track(0)
{
  verbose = G4ErrorPropagatorData::verbose();
#ifdef G4EVERBOSE
  if(verbose >= 5)
  {
    G4cout << "G4ErrorPropagator " << this << G4endl;
  }
#endif
 
  fpSteppingManager = G4EventManager::GetEventManager()
                        ->GetTrackingManager()
                        ->GetSteppingManager();
  thePropIsInitialized = false;
}

~G4ErrorPropagator()

G4ErrorPropagator::~G4ErrorPropagator ( )

inline

Definition at line 57 of file G4ErrorPropagator.hh.

{}

Member Function Documentation

CheckIfLastStep()

G4bool G4ErrorPropagator::CheckIfLastStep

(

G4Track *

aTrack

)

Definition at line 539 of file G4ErrorPropagator.cc.

{
  G4bool lastG4eStep = false;
  G4ErrorPropagatorData* g4edata =
    G4ErrorPropagatorData::GetErrorPropagatorData();
 
#ifdef G4EVERBOSE
  if(verbose >= 4)
  {
    G4cout << " G4ErrorPropagator::CheckIfLastStep G4ErrorState= "
           << G4int(g4edata->GetState()) << G4endl;
  }
#endif
 
  //----- Check if this is the last step: track has reached the target
  //      or the end of world
  //
  if(g4edata->GetState() == G4ErrorState(G4ErrorState_StoppedAtTarget))
  {
    lastG4eStep = true;
#ifdef G4EVERBOSE
    if(verbose >= 5)
    {
      G4cout << " G4ErrorPropagator::CheckIfLastStep " << lastG4eStep << " "
             << G4int(g4edata->GetState()) << G4endl;
    }
#endif
  }
  else if(aTrack->GetNextVolume() == 0)
  {
    //----- If particle is out of world, without finding the G4ErrorTarget,
    //      give a n error/warning
    //
    lastG4eStep = true;
    if(verbose >= 1)
    {
      std::ostringstream message;
      message << "Track extrapolated until end of World" << G4endl
              << "without finding the defined target.";
      G4Exception("G4ErrorPropagator::CheckIfLastStep()",
                  "GEANT4e-Notification", JustWarning, message);
    }
  }  //----- not last step from G4e, but track is stopped (energy exhausted)
  else if(aTrack->GetTrackStatus() == fStopAndKill)
  {
    if(verbose >= 1)
    {
      std::ostringstream message;
      message << "Track extrapolated until energy is exhausted" << G4endl
              << "without finding the defined target.";
      G4Exception("G4ErrorPropagator::CheckIfLastStep()",
                  "GEANT4e-Notification", JustWarning, message);
    }
    lastG4eStep = 1;
  }
 
#ifdef G4EVERBOSE
  if(verbose >= 5)
  {
    G4cout << " return CheckIfLastStep " << lastG4eStep << G4endl;
  }
#endif
 
  return lastG4eStep;
}

GetFinalTrajState()

void G4ErrorPropagator::GetFinalTrajState	(	G4ErrorTrajState *	currentTS,
		G4ErrorFreeTrajState *	currentTS_FREE,
		const G4ErrorTarget *	target )

Definition at line 494 of file G4ErrorPropagator.cc.

{
  G4ErrorPropagatorData* g4edata =
    G4ErrorPropagatorData::GetErrorPropagatorData();
 
#ifdef G4EVERBOSE
  if(verbose >= 1)
  {
    G4cout << " G4ErrorPropagator::Propagate: final state "
           << G4int(g4edata->GetState()) << " TSType " << currentTS->GetTSType()
           << G4endl;
  }
#endif
 
  if((currentTS->GetTSType() == G4eTS_FREE) ||
     (g4edata->GetState() != G4ErrorState_StoppedAtTarget))
  {
    currentTS = currentTS_FREE;
  }
  else if(currentTS->GetTSType() == G4eTS_OS)
  {
    if(target->GetType() == G4ErrorTarget_TrkL)
    {
      G4Exception("G4ErrorPropagator:GetFinalTrajState()", "InvalidSetup",
                  FatalException,
                  "Using a G4ErrorSurfaceTrajState with wrong target");
    }
    const G4ErrorTanPlaneTarget* targetWTP =
      static_cast<const G4ErrorTanPlaneTarget*>(target);
    *currentTS = G4ErrorSurfaceTrajState(
      *(static_cast<G4ErrorFreeTrajState*>(currentTS_FREE)),
      targetWTP->GetTangentPlane(currentTS_FREE->GetPosition()));
#ifdef G4EVERBOSE
    if(verbose >= 1)
    {
      G4cout << currentTS << " returning tssd " << *currentTS << G4endl;
    }
#endif
    delete currentTS_FREE;
  }
}

Referenced by Propagate(), and PropagateOneStep().

GetInitialTrajState()

const G4ErrorTrajState * G4ErrorPropagator::GetInitialTrajState ( ) const

inline

Definition at line 98 of file G4ErrorPropagator.hh.

  {
    return theInitialTrajState;
  }

GetStepLength()

G4double G4ErrorPropagator::GetStepLength ( ) const

inline

Definition at line 103 of file G4ErrorPropagator.hh.

{ return theStepLength; }

InitFreeTrajState()

G4ErrorFreeTrajState * G4ErrorPropagator::InitFreeTrajState

(

G4ErrorTrajState *

currentTS

)

Definition at line 466 of file G4ErrorPropagator.cc.

{
  G4ErrorFreeTrajState* currentTS_FREE = 0;
 
  //----- Transform the TrajState to Free coordinates if it is OnSurface
  //
  if(currentTS->GetTSType() == G4eTS_OS)
  {
    G4ErrorSurfaceTrajState* tssd =
      static_cast<G4ErrorSurfaceTrajState*>(currentTS);
    currentTS_FREE = new G4ErrorFreeTrajState(*tssd);
  }
  else if(currentTS->GetTSType() == G4eTS_FREE)
  {
    currentTS_FREE = static_cast<G4ErrorFreeTrajState*>(currentTS);
  }
  else
  {
    std::ostringstream message;
    message << "Wrong trajectory state: " << currentTS->GetTSType();
    G4Exception("G4ErrorPropagator::InitFreeTrajState()", "InvalidState",
                FatalException, message);
  }
  return currentTS_FREE;
}

Referenced by Propagate(), and PropagateOneStep().

InitG4Track()

G4Track * G4ErrorPropagator::InitG4Track

(

G4ErrorTrajState &

initialTS

)

Definition at line 264 of file G4ErrorPropagator.cc.

{
  if(verbose >= 5)
  {
    G4cout << "InitG4Track " << G4endl;
  }
 
  //----- Create Particle
  //
  const G4String partType        = initialTS.GetParticleType();
  G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
  G4ParticleDefinition* particle = particleTable->FindParticle(partType);
  if(particle == 0)
  {
    std::ostringstream message;
    message << "Particle type not defined: " << partType;
    G4Exception("G4ErrorPropagator::InitG4Track()", "InvalidSetup",
                FatalException, message);
  }
 
  G4DynamicParticle* DP =
    new G4DynamicParticle(particle, initialTS.GetMomentum());
 
  DP->SetPolarization(0., 0., 0.);
 
  // Set Charge
  //
  if(particle->GetPDGCharge() < 0)
  {
    DP->SetCharge(-eplus);
  }
  else
  {
    DP->SetCharge(eplus);
  }
 
  //----- Create Track
  //
  theG4Track = new G4Track(DP, 0., initialTS.GetPosition());
  theG4Track->SetParentID(0);
 
#ifdef G4EVERBOSE
  if(verbose >= 3)
  {
    G4cout << " G4ErrorPropagator new track of energy: "
           << theG4Track->GetKineticEnergy() << G4endl;
  }
#endif
 
  //---- Reproduce G4TrackingManager::ProcessOneTrack initialization
  InvokePreUserTrackingAction(theG4Track);
 
  if(fpSteppingManager == 0)
  {
    G4Exception("G4ErrorPropagator::InitG4Track()", "InvalidSetup",
                FatalException, "G4SteppingManager not initialized yet!");
  }
  else
  {
    fpSteppingManager->SetInitialStep(theG4Track);
  }
 
  // Give SteppingManger the maximum number of processes
  //
  fpSteppingManager->GetProcessNumber();
 
  // Give track the pointer to the Step
  //
  theG4Track->SetStep(fpSteppingManager->GetStep());
 
  // Inform beginning of tracking to physics processes
  //
  theG4Track->GetDefinition()->GetProcessManager()->StartTracking(theG4Track);
 
  initialTS.SetG4Track(theG4Track);
 
  return theG4Track;
}

Referenced by Propagate(), and PropagateOneStep().

InvokePostUserTrackingAction()

void G4ErrorPropagator::InvokePostUserTrackingAction

(

G4Track *

fpTrack

)

Definition at line 618 of file G4ErrorPropagator.cc.

{
  const G4UserTrackingAction* fpUserTrackingAction =
    G4EventManager::GetEventManager()->GetUserTrackingAction();
  if(fpUserTrackingAction != 0)
  {
    const_cast<G4UserTrackingAction*>(fpUserTrackingAction)
      ->PostUserTrackingAction((fpTrack));
  }
}

Referenced by Propagate().

InvokePreUserTrackingAction()

void G4ErrorPropagator::InvokePreUserTrackingAction

(

G4Track *

fpTrack

)

Definition at line 606 of file G4ErrorPropagator.cc.

{
  const G4UserTrackingAction* fpUserTrackingAction =
    G4EventManager::GetEventManager()->GetUserTrackingAction();
  if(fpUserTrackingAction != 0)
  {
    const_cast<G4UserTrackingAction*>(fpUserTrackingAction)
      ->PreUserTrackingAction((fpTrack));
  }
}

Referenced by InitG4Track().

MakeOneStep()

G4int G4ErrorPropagator::MakeOneStep

(

G4ErrorFreeTrajState *

currentTS_FREE

)

Definition at line 372 of file G4ErrorPropagator.cc.

{
  G4ErrorPropagatorData* g4edata =
    G4ErrorPropagatorData::GetErrorPropagatorData();
  G4int ierr = 0;
 
  //---------- Track one step
#ifdef G4EVERBOSE
  if(verbose >= 2)
  {
    G4cout << G4endl << "@@@@@@@@@@@@@@@@@@@@@@@@@ NEW STEP " << G4endl;
  }
#endif
 
  theG4Track->IncrementCurrentStepNumber();
 
  fpSteppingManager->Stepping();
 
  //---------- Check if Target has been reached (and then set G4ErrorState)
 
  // G4ErrorPropagationNavigator limits the step if target is closer than
  // boundary (but the winner process is always "Transportation": then
  // error propagator will stop the track
 
  if(theG4Track->GetStep()
       ->GetPostStepPoint()
       ->GetProcessDefinedStep()
       ->GetProcessName() == "Transportation")
  {
    if(g4edata->GetState() ==
       G4ErrorState(G4ErrorState_TargetCloserThanBoundary))
    {  // target or step length reached
 
#ifdef G4EVERBOSE
      if(verbose >= 5)
      {
        G4cout << " transportation determined by geant4e " << G4endl;
      }
#endif
      g4edata->SetState(G4ErrorState_StoppedAtTarget);
    }
    else if(g4edata->GetTarget()->GetType() == G4ErrorTarget_GeomVolume)
    {
      G4ErrorGeomVolumeTarget* target =
        (G4ErrorGeomVolumeTarget*) (g4edata->GetTarget());
      if(static_cast<G4ErrorGeomVolumeTarget*>(target)->TargetReached(
           theG4Track->GetStep()))
      {
        g4edata->SetState(G4ErrorState_StoppedAtTarget);
      }
    }
  }
  else if(theG4Track->GetStep()
            ->GetPostStepPoint()
            ->GetProcessDefinedStep()
            ->GetProcessName() == "G4ErrorTrackLengthTarget")
  {
    g4edata->SetState(G4ErrorState_StoppedAtTarget);
  }
 
  //---------- Propagate error
 
#ifdef G4EVERBOSE
  if(verbose >= 2)
  {
    G4cout << " propagating error " << *currentTS_FREE << G4endl;
  }
#endif
  const G4Track* cTrack = const_cast<G4Track*>(theG4Track);
  ierr                  = currentTS_FREE->PropagateError(cTrack);
 
#ifdef G4EVERBOSE
  if(verbose >= 3)
  {
    G4cout << " PropagateError returns " << ierr << G4endl;
  }
#endif
 
  currentTS_FREE->Update(cTrack);
 
  theStepLength += theG4Track->GetStepLength();
 
  if(ierr != 0)
  {
    std::ostringstream message;
    message << "Error returned: " << ierr;
    G4Exception("G4ErrorPropagator::MakeOneStep()", "GEANT4e-Notification",
                JustWarning, message, "Geant4 tracking will be stopped !");
  }
 
  return ierr;
}

Referenced by PropagateOneStep().

Propagate()

G4int G4ErrorPropagator::Propagate	(	G4ErrorTrajState *	currentTS,
		const G4ErrorTarget *	target,
		G4ErrorMode	mode = G4ErrorMode_PropForwards )

Definition at line 76 of file G4ErrorPropagator.cc.

{
  // to start ierror is set to 1 (= OK)
  //
  G4int ierr = 1;
 
  G4ErrorPropagatorData* g4edata =
    G4ErrorPropagatorData::GetErrorPropagatorData();
 
  //----- Do not propagate zero or too low energy particles
  //
  if(currentTS->GetMomentum().mag() < 1.E-9 * MeV)
  {
    std::ostringstream message;
    message << "Energy too low to be propagated: "
            << G4BestUnit(currentTS->GetMomentum().mag(), "Energy");
    G4Exception("G4ErrorPropagator::Propagate()", "GEANT4e-Notification",
                JustWarning, message);
    return -3;
  }
 
  g4edata->SetMode(mode);
 
#ifdef G4EVERBOSE
  if(verbose >= 1)
  {
    G4cout << " =====> starting GEANT4E tracking for "
           << currentTS->GetParticleType()
           << "  Forwards= " << g4edata->GetMode() << G4endl;
  }
  if(verbose >= 1)
  {
    G4cout << G4endl << "@@@@@@@@@@@@@@@@@@@@@@@@@ NEW STEP " << G4endl;
  }
 
  if(verbose >= 3)
  {
    G4cout << " G4ErrorPropagator::Propagate initialTS ";
    G4cout << *currentTS << G4endl;
    target->Dump(G4String(" to target "));
  }
#endif
 
  g4edata->SetTarget(target);
 
  //----- Create a track
  //
  if(theG4Track != 0)
  {
    delete theG4Track;
  }
  theG4Track = InitG4Track(*currentTS);
 
  //----- Create a G4ErrorFreeTrajState
  //
  G4ErrorFreeTrajState* currentTS_FREE = InitFreeTrajState(currentTS);
 
  //----- Track the particle
  //
  ierr = MakeSteps(currentTS_FREE);
 
  //------ Tracking ended, check if target has been reached
  //       if target not found
  //
  if(g4edata->GetState() != G4ErrorState_StoppedAtTarget)
  {
    if(theG4Track->GetKineticEnergy() > 0.)
    {
      ierr = -ierr - 10;
    }
    else
    {
      ierr = -ierr - 20;
    }
    *currentTS = *currentTS_FREE;
    if(verbose >= 0)
    {
      std::ostringstream message;
      message << "Particle does not reach target: " << *currentTS;
      G4Exception("G4ErrorPropagator::Propagate()", "GEANT4e-Notification",
                  JustWarning, message);
    }
  }
  else
  {
    GetFinalTrajState(currentTS, currentTS_FREE, target);
  }
 
#ifdef G4EVERBOSE
  if(verbose >= 1)
  {
    G4cout << " G4ErrorPropagator: propagation ended " << G4endl;
  }
  if(verbose >= 2)
  {
    G4cout << " Current TrajState " << currentTS << G4endl;
  }
#endif
 
  // Inform end of tracking to physics processes
  //
  theG4Track->GetDefinition()->GetProcessManager()->EndTracking();
 
  InvokePostUserTrackingAction(theG4Track);
 
  // delete currentTS_FREE;
 
  return ierr;
}

PropagateOneStep()

G4int G4ErrorPropagator::PropagateOneStep

(

G4ErrorTrajState *

currentTS

)

Definition at line 189 of file G4ErrorPropagator.cc.

{
  G4ErrorPropagatorData* g4edata =
    G4ErrorPropagatorData::GetErrorPropagatorData();
 
  if((g4edata->GetState() == G4ErrorState_PreInit) ||
     (G4StateManager::GetStateManager()->GetCurrentState() !=
      G4State_GeomClosed))
  {
    std::ostringstream message;
    message << "Called before initialization is done for this track!";
    G4Exception("G4ErrorPropagator::PropagateOneStep()", "InvalidCall",
                FatalException, message,
                "Please call G4ErrorPropagatorManager::InitGeant4e().");
  }
 
  // to start ierror is set to 0 (= OK)
  //
  G4int ierr = 0;
 
  //--- Do not propagate zero or too low energy particles
  //
  if(currentTS->GetMomentum().mag() < 1.E-9 * MeV)
  {
    std::ostringstream message;
    message << "Energy too low to be propagated: "
            << G4BestUnit(currentTS->GetMomentum().mag(), "Energy");
    G4Exception("G4ErrorPropagator::PropagateOneStep()", "GEANT4e-Notification",
                JustWarning, message);
    return -3;
  }
 
#ifdef G4EVERBOSE
  if(verbose >= 1)
  {
    G4cout << " =====> starting GEANT4E tracking for "
           << currentTS->GetParticleType()
           << "  Forwards= " << g4edata->GetMode() << G4endl;
  }
  if(verbose >= 3)
  {
    G4cout << " G4ErrorPropagator::Propagate initialTS ";
    G4cout << *currentTS << G4endl;
  }
#endif
 
  //----- If it is the first step, create a track
  //
  if(theStepN == 0)
  {
    if(theG4Track != 0)
    {
      delete theG4Track;
    }
    theG4Track = InitG4Track(*currentTS);
  }
  // set to 0 by the initialization in G4ErrorPropagatorManager
  theStepN++;
 
  //----- Create a G4ErrorFreeTrajState
  //
  G4ErrorFreeTrajState* currentTS_FREE = InitFreeTrajState(currentTS);
 
  //----- Track the particle one step
  //
  ierr = MakeOneStep(currentTS_FREE);
 
  //----- Get the state on target
  //
  GetFinalTrajState(currentTS, currentTS_FREE, g4edata->GetTarget());
 
  return ierr;
}

SetStepLength()

void G4ErrorPropagator::SetStepLength ( const G4double sl )

inline

Definition at line 105 of file G4ErrorPropagator.hh.

{ theStepLength = sl; }

SetStepN()

void G4ErrorPropagator::SetStepN ( const G4int sn )

inline

Definition at line 107 of file G4ErrorPropagator.hh.

{ theStepN = sn; }

---

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

• G4ErrorPropagator.hh
• G4ErrorPropagator.cc