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

---

Constructor & Destructor Documentation

G4ErrorPropagator::G4ErrorPropagator

(

)

Definition at line 57 of file G4ErrorPropagator.cc.

References G4cout, G4endl, G4EventManager::GetEventManager(), G4TrackingManager::GetSteppingManager(), G4EventManager::GetTrackingManager(), and G4ErrorPropagatorData::verbose().

  : 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

(

)

[inline]

Definition at line 59 of file G4ErrorPropagator.hh.

{}

---

Member Function Documentation

G4bool G4ErrorPropagator::CheckIfLastStep

(

G4Track *

aTrack

)

Definition at line 520 of file G4ErrorPropagator.cc.

References FatalException, fStopAndKill, G4cerr, G4cout, G4endl, G4ErrorState_StoppedAtTarget, G4Exception(), G4ErrorPropagatorData::GetErrorPropagatorData(), G4Track::GetNextVolume(), G4ErrorPropagatorData::GetState(), and G4Track::GetTrackStatus().

{
  G4bool exception = 0;
  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( exception )
    {
      std::ostringstream message;
      message << "Track extrapolated until end of World" << G4endl
              << "without finding the defined target!";
      G4Exception("G4ErrorPropagator::CheckIfLastStep()",
                  "InvalidSetup", FatalException, message);
    }
    else
    {
      if( verbose >= 1 )
      {
        G4cerr << "ERROR - G4ErrorPropagator::CheckIfLastStep()" << G4endl
               << "        Track extrapolated until end of World" << G4endl
               << "        without finding the defined target " << G4endl;
      }
    }
  }  //----- not last step from G4e, but track is stopped (energy exhausted)
  else if( aTrack->GetTrackStatus() == fStopAndKill )
  { 
    if( exception )
    {
      std::ostringstream message;
      message << "Track extrapolated until energy is exhausted" << G4endl
              << "without finding the defined target!";
      G4Exception("G4ErrorPropagator::CheckIfLastStep()",
                  "InvalidSetup", FatalException, message);
    }
    else
    {
      if( verbose >= 1 )
      {
        G4cerr << "ERROR - G4ErrorPropagator::CheckIfLastStep()" << G4endl
             << "        Track extrapolated until energy is exhausted" << G4endl
             << "        without finding the defined target !" << G4endl;
      }
      lastG4eStep = 1;
    }
  }

#ifdef G4EVERBOSE
  if( verbose >= 5 )
  {
    G4cout << " return CheckIfLastStep " << lastG4eStep << G4endl;
  }
#endif

  return  lastG4eStep;
}

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

Definition at line 474 of file G4ErrorPropagator.cc.

References FatalException, G4cout, G4endl, G4ErrorState_StoppedAtTarget, G4ErrorTarget_TrkL, G4eTS_FREE, G4eTS_OS, G4Exception(), G4ErrorPropagatorData::GetErrorPropagatorData(), G4ErrorPropagatorData::GetState(), G4ErrorTanPlaneTarget::GetTangentPlane(), G4ErrorTrajState::GetTSType(), and G4ErrorTarget::GetType().

Referenced by Propagate(), and PropagateOneStep().

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

const G4ErrorTrajState* G4ErrorPropagator::GetInitialTrajState

(

)

const [inline]

Definition at line 99 of file G4ErrorPropagator.hh.

    { return theInitialTrajState; }

G4double G4ErrorPropagator::GetStepLength

(

)

const [inline]

Definition at line 102 of file G4ErrorPropagator.hh.

    { return theStepLength; }

G4ErrorFreeTrajState * G4ErrorPropagator::InitFreeTrajState

(

G4ErrorTrajState *

currentTS

)

Definition at line 446 of file G4ErrorPropagator.cc.

References FatalException, G4eTS_FREE, G4eTS_OS, G4Exception(), and G4ErrorTrajState::GetTSType().

Referenced by Propagate(), and PropagateOneStep().

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

G4Track * G4ErrorPropagator::InitG4Track

(

G4ErrorTrajState &

initialTS

)

Definition at line 250 of file G4ErrorPropagator.cc.

References FatalException, G4ParticleTable::FindParticle(), G4cout, G4endl, G4Exception(), G4Track::GetDefinition(), G4Track::GetKineticEnergy(), G4ErrorTrajState::GetMomentum(), G4ParticleTable::GetParticleTable(), G4ErrorTrajState::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ErrorTrajState::GetPosition(), G4ParticleDefinition::GetProcessManager(), G4SteppingManager::GetProcessNumber(), G4SteppingManager::GetStep(), InvokePreUserTrackingAction(), G4DynamicParticle::SetCharge(), G4ErrorTrajState::SetG4Track(), G4SteppingManager::SetInitialStep(), G4Track::SetParentID(), G4DynamicParticle::SetPolarization(), G4Track::SetStep(), and G4ProcessManager::StartTracking().

Referenced by Propagate(), and PropagateOneStep().

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

void G4ErrorPropagator::InvokePostUserTrackingAction

(

G4Track *

fpTrack

)

Definition at line 620 of file G4ErrorPropagator.cc.

References G4EventManager::GetEventManager(), and G4EventManager::GetUserTrackingAction().

Referenced by Propagate().

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

void G4ErrorPropagator::InvokePreUserTrackingAction

(

G4Track *

fpTrack

)

Definition at line 607 of file G4ErrorPropagator.cc.

References G4EventManager::GetEventManager(), and G4EventManager::GetUserTrackingAction().

Referenced by InitG4Track().

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

G4int G4ErrorPropagator::MakeOneStep

(

G4ErrorFreeTrajState *

currentTS_FREE

)

Definition at line 354 of file G4ErrorPropagator.cc.

References G4cerr, G4cout, G4endl, G4ErrorState_StoppedAtTarget, G4ErrorState_TargetCloserThanBoundary, G4ErrorTarget_GeomVolume, G4ErrorPropagatorData::GetErrorPropagatorData(), G4Step::GetPostStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4VProcess::GetProcessName(), G4ErrorPropagatorData::GetState(), G4Track::GetStep(), G4Track::GetStepLength(), G4ErrorPropagatorData::GetTarget(), G4ErrorTarget::GetType(), G4Track::IncrementCurrentStepNumber(), G4ErrorFreeTrajState::PropagateError(), G4ErrorPropagatorData::SetState(), G4SteppingManager::Stepping(), and G4ErrorFreeTrajState::Update().

Referenced by PropagateOneStep().

{
  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 )
  {
    G4cerr << "ERROR - G4ErrorPropagator:MakeOneStep()" << G4endl
           << "        Error returned: " << ierr << G4endl
           << "        Geant4 tracking will be stopped !" << G4endl;
  }

  return ierr; 
}

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

Definition at line 72 of file G4ErrorPropagator.cc.

References G4ErrorTarget::Dump(), G4ProcessManager::EndTracking(), G4BestUnit, G4cerr, G4cout, G4endl, G4ErrorState_StoppedAtTarget, G4Track::GetDefinition(), G4ErrorPropagatorData::GetErrorPropagatorData(), GetFinalTrajState(), G4Track::GetKineticEnergy(), G4ErrorPropagatorData::GetMode(), G4ErrorTrajState::GetMomentum(), G4ErrorTrajState::GetParticleType(), G4ParticleDefinition::GetProcessManager(), G4ErrorPropagatorData::GetState(), InitFreeTrajState(), InitG4Track(), InvokePostUserTrackingAction(), G4ErrorPropagatorData::SetMode(), and G4ErrorPropagatorData::SetTarget().

Referenced by G4ErrorPropagatorManager::Propagate().

{
  // 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 )
  {
    G4cerr << "ERROR - G4ErrorPropagator::Propagate()" << G4endl
           << "        Energy too low to be propagated: "
           << G4BestUnit(currentTS->GetMomentum().mag(),"Energy") << G4endl;
    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 )
    {
       G4cerr << "ERROR - G4ErrorPropagator::Propagate()" << G4endl
              << "        Particle does not reach target: " << *currentTS
              << G4endl;
    }
  }
  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;
}

G4int G4ErrorPropagator::PropagateOneStep

(

G4ErrorTrajState *

currentTS

)

Definition at line 179 of file G4ErrorPropagator.cc.

References FatalException, G4BestUnit, G4cerr, G4cout, G4endl, G4ErrorState_PreInit, G4Exception(), G4State_GeomClosed, G4ErrorPropagatorData::GetErrorPropagatorData(), GetFinalTrajState(), G4ErrorPropagatorData::GetMode(), G4ErrorTrajState::GetMomentum(), G4ErrorTrajState::GetParticleType(), G4ErrorPropagatorData::GetState(), G4StateManager::GetStateManager(), G4ErrorPropagatorData::GetTarget(), InitFreeTrajState(), InitG4Track(), and MakeOneStep().

Referenced by G4ErrorPropagatorManager::PropagateOneStep().

{
  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 )
  {
    G4cerr << "ERROR - G4ErrorPropagator::PropagateOneStep()" << G4endl
           << "        Energy too low to be propagated: "
           << G4BestUnit(currentTS->GetMomentum().mag(),"Energy") << G4endl;
    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;
}

void G4ErrorPropagator::SetStepLength

(

const G4double

sl

)

[inline]

Definition at line 105 of file G4ErrorPropagator.hh.

    { theStepLength = sl; }

void G4ErrorPropagator::SetStepN

(

const G4int

sn

)

[inline]

Definition at line 108 of file G4ErrorPropagator.hh.

Referenced by G4ErrorPropagatorManager::InitTrackPropagation().

    { theStepN = sn; }

---

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

• G4ErrorPropagator.hh
• G4ErrorPropagator.cc

---