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 56 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 58 of file G4ErrorPropagator.hh.

{}

Member Function Documentation

CheckIfLastStep()

G4bool G4ErrorPropagator::CheckIfLastStep

(

G4Track *

aTrack

)

Definition at line 526 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 480 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 101 of file G4ErrorPropagator.hh.

    { return theStepLength; }

InitFreeTrajState()

G4ErrorFreeTrajState * G4ErrorPropagator::InitFreeTrajState

(

G4ErrorTrajState *

currentTS

)

Definition at line 452 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 254 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 607 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 594 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 358 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 71 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;
}

Referenced by G4ErrorPropagatorManager::Propagate().

PropagateOneStep()

G4int G4ErrorPropagator::PropagateOneStep

(

G4ErrorTrajState *

currentTS

)

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

Referenced by G4ErrorPropagatorManager::PropagateOneStep().

SetStepLength()

void G4ErrorPropagator::SetStepLength ( const G4double  sl )

inline

Definition at line 104 of file G4ErrorPropagator.hh.

    { theStepLength = sl; }

SetStepN()

void G4ErrorPropagator::SetStepN ( const G4int  sn )

inline

Definition at line 107 of file G4ErrorPropagator.hh.

    { theStepN = sn; }

Referenced by G4ErrorPropagatorManager::InitTrackPropagation().

---

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

• G4ErrorPropagator.hh
• G4ErrorPropagator.cc