#include <G4ITStepProcessor.hh>

Public Member Functions
	G4ITStepProcessor ()

virtual	~G4ITStepProcessor ()

void	SetPreviousStepTime (G4double)

G4Track *	GetTrack ()

G4Step *	GetStep ()

const G4Step *	GetStep () const

void	SetStep (G4Step *val)

G4TrackVector *	GetSecondaries ()

void	SetTrackingManager (G4ITTrackingManager *trackMan)

G4ITTrackingManager *	GetTrackingManager ()

virtual void	Initialize ()

void	ForceReInitialization ()

void	DefinePhysicalStepLength (G4Track *)

void	Stepping (G4Track *, const double &)

void	CalculateStep (G4Track *, const double &)

void	CalculateStep (G4Track *)

void	DoIt (G4Track *, double)

void	FindTransportationStep ()

void	UpdateTrack (G4Track *)

double	GetInteractionTime ()

const G4Track *	GetTrack () const

void	CleanProcessor ()

Protected Member Functions
void	SetupGeneralProcessInfo (G4ParticleDefinition , G4ProcessManager )

void	ClearProcessInfo ()

void	SetTrack (G4Track *)

void	GetProcessInfo ()

void	SetupMembers ()

void	ResetSecondaries ()

void	InitDefineStep ()

void	SetInitialStep ()

void	GetAtRestIL ()

void	DoDefinePhysicalStepLength ()

void	DoStepping ()

void	CalculateStep ()

void	DoCalculateStep ()

void	CloneProcesses ()

void	ActiveOnlyITProcess ()

void	ActiveOnlyITProcess (G4ProcessManager *)

void	DealWithSecondaries (G4int &)

void	InvokeAtRestDoItProcs ()

void	InvokeAlongStepDoItProcs ()

void	InvokePostStepDoItProcs ()

void	InvokePSDIP (size_t)

void	InvokeTransportationProc ()

void	SetNavigator (G4ITNavigator *value)

G4double	CalculateSafety ()

void	ApplyProductionCut (G4Track *)

	G4ITStepProcessor (const G4ITStepProcessor &other)

G4ITStepProcessor &	operator= (const G4ITStepProcessor &other)

Detailed Description

Its role is the same as G4StepManager :

Find the minimum physical length and corresponding time step
Step one track BUT on a given time step.

Definition at line 83 of file G4ITStepProcessor.hh.

Constructor & Destructor Documentation

G4ITStepProcessor::G4ITStepProcessor ( )

Definition at line 63 of file G4ITStepProcessor.cc.

References DBL_MAX.

 {
     verboseLevel = 0 ;
     //    fpUserSteppingAction = 0 ;
     fStoreTrajectory = 0;
     fpTrackingManager = 0;
     fpNavigator = 0;
     kCarTolerance = -1.;
     fInitialized = false;
     fPreviousTimeStep = DBL_MAX;
     CleanProcessor();
     ResetSecondaries();
 }

G4ITStepProcessor::~G4ITStepProcessor ( )

virtual

Definition at line 189 of file G4ITStepProcessor.cc.

References ClearProcessInfo(), G4ITTransportationManager::DeleteInstance(), and G4Step::DeleteSecondaryVector().

 {
     if(fpStep)
     {
         fpStep->DeleteSecondaryVector();
         delete fpStep;
     }
 
     if(fpSecondary)                      delete fpSecondary;
     ClearProcessInfo();
     G4ITTransportationManager::DeleteInstance();
 
     //    if(fpUserSteppingAction)             delete fpUserSteppingAction;
 }

G4ITStepProcessor::G4ITStepProcessor ( const G4ITStepProcessor & other )

protected

Definition at line 205 of file G4ITStepProcessor.cc.

References CleanProcessor(), DBL_MAX, and ResetSecondaries().

 {
     verboseLevel = rhs.verboseLevel ;
     fStoreTrajectory = rhs.fStoreTrajectory ;
 
     //    fpUserSteppingAction = 0 ;
     fpTrackingManager = 0;
     fpNavigator = 0;
     fInitialized = false;
 
     kCarTolerance = rhs.kCarTolerance;
     fInitialized = false;
     fPreviousTimeStep = DBL_MAX;
 
     CleanProcessor();
     ResetSecondaries();
 }

Member Function Documentation

void G4ITStepProcessor::ActiveOnlyITProcess ( )

protected

Definition at line 232 of file G4ITStepProcessor.cc.

References FatalException, G4cerr, G4cout, G4endl, G4Exception(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetProcessManager(), G4ParticleTableIterator< K, V >::reset(), theParticleIterator, and G4ParticleTableIterator< K, V >::value().

 {
     // Method not used for the time being
 #ifdef debug
     G4cout<<"G4ITStepProcessor::CloneProcesses: is called"<<G4endl;
 #endif
 
     G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
     G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();
 
     theParticleIterator->reset();
     // TODO : Ne faire la boucle que sur les IT **** !!!
     while( (*theParticleIterator)() )
     {
         G4ParticleDefinition* particle = theParticleIterator->value();
         G4ProcessManager* pm= particle->GetProcessManager();
 
         if(!pm)
         {
             G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
                    << "        ProcessManager is NULL for particle = "
                    << particle->GetParticleName() << ", PDG_code = "
                    << particle->GetPDGEncoding() << G4endl;
             G4Exception("G4ITStepProcessor::GetProcessNumber()", "ITStepProcessor0001",
                         FatalException, "Process Manager is not found.");
             return;
         }
 
         ActiveOnlyITProcess(pm);
     }
 }

void G4ITStepProcessor::ActiveOnlyITProcess ( G4ProcessManager * processManager )

protected

Definition at line 265 of file G4ITStepProcessor.cc.

References G4ProcessManager::GetProcessList(), G4ProcessManager::SetProcessActivation(), and G4ProcessVector::size().

 {
     // Method not used for the time being
     G4ProcessVector* processVector = processManager->GetProcessList();
 
     G4VITProcess* itProcess = 0 ;
     for(int i = 0 ; i < processVector->size() ; i++)
     {
         G4VProcess* base_process = (*processVector)[i];
         itProcess = dynamic_cast<G4VITProcess*>(base_process);
 
         if(!itProcess)
         {
             processManager->SetProcessActivation(base_process, false);
         }
     }
 }

void G4ITStepProcessor::ApplyProductionCut ( G4Track * aSecondary )

protected

Definition at line 569 of file G4ITStepProcessor2.cc.

References G4Step::AddTotalEnergyDeposit(), CalculateSafety(), DBL_MIN, G4DynamicParticle::GetCharge(), G4ProductionCutsTable::GetCoupleIndex(), G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4ProductionCutsTable::GetEnergyCutsVector(), G4ProductionCuts::GetIndex(), G4Track::GetKineticEnergy(), G4StepPoint::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetRange(), G4LossTableManager::Instance(), G4Track::IsGoodForTracking(), and G4Track::SetKineticEnergy().

Referenced by DealWithSecondaries().

 {
     G4bool tBelowCutEnergyAndSafety = false;
     G4int tPtclIdx
             = G4ProductionCuts::GetIndex(aSecondary->GetDefinition());
     if (tPtclIdx<0)
     {
         return;
     }
     G4ProductionCutsTable* tCutsTbl
             = G4ProductionCutsTable::GetProductionCutsTable();
     G4int tCoupleIdx
             = tCutsTbl->GetCoupleIndex(fpPreStepPoint->GetMaterialCutsCouple());
     G4double tProdThreshold
             = (*(tCutsTbl->GetEnergyCutsVector(tPtclIdx)))[tCoupleIdx];
     if( aSecondary->GetKineticEnergy()<tProdThreshold )
     {
         tBelowCutEnergyAndSafety = true;
         if(std::abs(aSecondary->GetDynamicParticle()->GetCharge()) > DBL_MIN)
         {
             G4double currentRange
                     = G4LossTableManager::Instance()->GetRange(aSecondary->GetDefinition(),
                                                                aSecondary->GetKineticEnergy(),
                                                                fpPreStepPoint->GetMaterialCutsCouple());
             tBelowCutEnergyAndSafety = (currentRange < CalculateSafety() );
         }
     }
 
     if( tBelowCutEnergyAndSafety )
     {
         if( !(aSecondary->IsGoodForTracking()) )
         {
             // Add kinetic energy to the total energy deposit
             fpStep->AddTotalEnergyDeposit(
                         aSecondary->GetKineticEnergy() );
             aSecondary->SetKineticEnergy(0.0);
         }
     }
 }

G4double G4ITStepProcessor::CalculateSafety ( )

inlineprotected

Definition at line 314 of file G4ITStepProcessor.hh.

References G4StepPoint::GetPosition(), and G4INCL::Math::max().

Referenced by ApplyProductionCut(), and InvokePSDIP().

 {
     return std::max( fpState->endpointSafety -
                      (fpState->endpointSafOrigin - fpPostStepPoint->GetPosition()).mag(),
                      kCarTolerance );
 }

void G4ITStepProcessor::CalculateStep	(	G4Track *	,
		const double &
	)

void G4ITStepProcessor::CalculateStep ( G4Track * )

void G4ITStepProcessor::CalculateStep ( )

protected

void G4ITStepProcessor::CleanProcessor ( )

inline

Definition at line 326 of file G4ITStepProcessor.hh.

References DBL_MAX, INT_MAX, NotCandidateForSelection, and NotForced.

Referenced by G4ITStepProcessor(), Initialize(), and Stepping().

 {
     fTimeStep = DBL_MAX ;
     fPhysIntLength = DBL_MAX;
 
     fpState = 0;
     fpTrack = 0;
     fpTrackingInfo = 0 ;
     fpITrack = 0;
     fpStep = 0;
     fpPreStepPoint = 0;
     fpPostStepPoint = 0;
 
     fpParticleChange = 0;
 
     fpCurrentVolume = 0;
 //    fpSensitive = 0;
 
     fpSecondary = 0 ;
 
     fpTransportation = 0;
 
     fpCurrentProcess= 0;
     fpProcessInfo = 0;
 
     fAtRestDoItProcTriggered = INT_MAX;
     fPostStepDoItProcTriggered = INT_MAX;
     fPostStepAtTimeDoItProcTriggered = INT_MAX;
     fGPILSelection = NotCandidateForSelection ;
     fCondition = NotForced;
 }

void G4ITStepProcessor::ClearProcessInfo ( )

protected

Definition at line 146 of file G4ITStepProcessor.cc.

Referenced by ForceReInitialization(), and ~G4ITStepProcessor().

 {
     std::map<const G4ParticleDefinition*, ProcessGeneralInfo*> ::iterator it;
 
     for(it = fProcessGeneralInfoMap.begin();it != fProcessGeneralInfoMap.end();it++)
     {
         if(it->second)
         {
             delete it->second;
             it->second = 0;
         }
     }
 
     fProcessGeneralInfoMap.clear();
 }

void G4ITStepProcessor::CloneProcesses ( )

protected

void G4ITStepProcessor::DealWithSecondaries ( G4int & counter )

protected

Definition at line 49 of file G4ITStepProcessor2.cc.

References ApplyProductionCut(), DBL_MIN, G4ProcessVector::entries(), fStopButAlive, G4ParticleDefinition::GetApplyCutsFlag(), G4ProcessManager::GetAtRestProcessVector(), G4Track::GetDefinition(), G4Track::GetKineticEnergy(), G4VParticleChange::GetNumberOfSecondaries(), G4ParticleDefinition::GetProcessManager(), G4VParticleChange::GetSecondary(), G4Track::GetTrackID(), G4Track::SetCreatorProcess(), G4Track::SetParentID(), and G4Track::SetTrackStatus().

Referenced by InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), and InvokePSDIP().

 {
     // Now Store the secondaries from ParticleChange to SecondaryList
     G4Track* tempSecondaryTrack;
 
     for(G4int DSecLoop=0 ;
         DSecLoop<fpParticleChange->GetNumberOfSecondaries() ;
         DSecLoop++)
     {
         tempSecondaryTrack = fpParticleChange->GetSecondary(DSecLoop);
 
         if(tempSecondaryTrack->GetDefinition()->GetApplyCutsFlag())
         {
             ApplyProductionCut(tempSecondaryTrack);
         }
 
         // Set parentID
         tempSecondaryTrack->SetParentID( fpTrack->GetTrackID() );
 
         // Set the process pointer which created this track
         tempSecondaryTrack->SetCreatorProcess( fpCurrentProcess );
 
         // If this 2ndry particle has 'zero' kinetic energy, make sure
         // it invokes a rest process at the beginning of the tracking
         if(tempSecondaryTrack->GetKineticEnergy() <= DBL_MIN)
         {
             G4ProcessManager* pm = tempSecondaryTrack->GetDefinition()->GetProcessManager();
             if (pm->GetAtRestProcessVector()->entries()>0){
                 tempSecondaryTrack->SetTrackStatus( fStopButAlive );
                 fpSecondary->push_back( tempSecondaryTrack );
                 fN2ndariesAtRestDoIt++;
             } else {
                 delete tempSecondaryTrack;
             }
         }
         else
         {
             fpSecondary->push_back( tempSecondaryTrack );
             counter++;
         }
     } //end of loop on secondary
 }

void G4ITStepProcessor::DefinePhysicalStepLength ( G4Track * track )

Definition at line 514 of file G4ITStepProcessor.cc.

References DoDefinePhysicalStepLength(), and SetTrack().

 {
     SetTrack(track);
     DoDefinePhysicalStepLength();
 }

void G4ITStepProcessor::DoCalculateStep ( )

protected

void G4ITStepProcessor::DoDefinePhysicalStepLength ( )

protected

Definition at line 704 of file G4ITStepProcessor.cc.

References CandidateForSelection, G4ITTransportation::ComputeStep(), Conditionally, DBL_MAX, ExclusivelyForced, fAlongStepDoItProc, FatalErrorInArgument, FatalException, fExclusivelyForcedProc, fGeomBoundary, Forced, fPostStepDoItProc, fStopAndKill, fStopButAlive, fWorldBoundary, G4Exception(), GetAtRestIL(), G4VITProcess::GetInteractionTimeLeft(), G4ITNavigator::GetNavigatorState(), G4Track::GetNextVolume(), G4Step::GetPostStepPoint(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4IT::GetTrackingInfo(), InActivated, InitDefineStep(), NotForced, G4VITProcess::ProposesTimeStep(), G4ITNavigator::SetNavigatorState(), G4TrackingInformation::SetNavigatorState(), G4StepPoint::SetProcessDefinedStep(), G4VITProcess::SetProcessState(), and StronglyForced.

Referenced by DefinePhysicalStepLength().

 {
 
     InitDefineStep();
 
     G4TrackStatus trackStatus = fpTrack -> GetTrackStatus()  ;
 
     if(trackStatus == fStopAndKill)
     {
         return ;
     }
 
     if(trackStatus == fStopButAlive)
     {
         fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
         fpNavigator->SetNavigatorState(0);
         return GetAtRestIL() ;
     }
 
 
     // Find minimum Step length and corresponding time
     // demanded by active disc./cont. processes
 
     // ReSet the counter etc.
     fpState->fPhysicalStep  = DBL_MAX;          // Initialize by a huge number
     fPhysIntLength = DBL_MAX;          // Initialize by a huge number
 
     double proposedTimeStep = DBL_MAX;
     G4VProcess* processWithPostStepGivenByTimeStep(0);
 
     // GPIL for PostStep
     fPostStepDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
     fPostStepAtTimeDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
 
     //    G4cout << "fpProcessInfo->MAXofPostStepLoops : " << fpProcessInfo->MAXofPostStepLoops
     //           << " mol : " << fpITrack -> GetName() << " id : " << fpTrack->GetTrackID()
     //           << G4endl;
 
     for(size_t np=0; np < fpProcessInfo->MAXofPostStepLoops; np++)
     {
         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepGetPhysIntVector)[np];
         if (fpCurrentProcess== 0)
         {
             (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
             continue;
         }   // NULL means the process is inactivated by a user on fly.
 
         fCondition=NotForced;
         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
 
         //        G4cout << "Is going to call : " << fpCurrentProcess -> GetProcessName() << G4endl;
         fPhysIntLength = fpCurrentProcess->
                 PostStepGPIL( *fpTrack,
                               fpState->fPreviousStepSize,
                               &fCondition );
         fpCurrentProcess->SetProcessState(0);
 
         switch (fCondition)
         {
         case ExclusivelyForced: // Will need special treatment
             (fpState->fSelectedPostStepDoItVector)[np] = ExclusivelyForced;
             fpState->fStepStatus = fExclusivelyForcedProc;
             fpStep->GetPostStepPoint()
                     ->SetProcessDefinedStep(fpCurrentProcess);
             break;
 
         case Conditionally:
             //       (fpState->fSelectedPostStepDoItVector)[np] = Conditionally;
             G4Exception("G4ITStepProcessor::DefinePhysicalStepLength()", "ITStepProcessor0008",
                         FatalException, "This feature is no more supported");
             break;
 
         case Forced:
             (fpState->fSelectedPostStepDoItVector)[np] = Forced;
             break;
 
         case StronglyForced:
             (fpState->fSelectedPostStepDoItVector)[np] = StronglyForced;
             break;
 
         default:
             (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
             break;
         }
 
         if (fCondition==ExclusivelyForced)
         {
             for(size_t nrest=np+1; nrest < fpProcessInfo->MAXofPostStepLoops; nrest++)
             {
                 (fpState->fSelectedPostStepDoItVector)[nrest] = InActivated;
             }
             return;  // Please note the 'return' at here !!!
         }
         else
         {
             if(fPhysIntLength < fpState->fPhysicalStep )
             {
                 // To avoid checking whether the process is actually
                 // proposing a time step, the returned time steps are
                 // negative (just for tagging)
                 if(fpCurrentProcess->ProposesTimeStep())
                 {
                     fPhysIntLength *= -1;
                     if(fPhysIntLength < proposedTimeStep)
                     {
                         proposedTimeStep = fPhysIntLength;
                         fPostStepAtTimeDoItProcTriggered = np;
                         processWithPostStepGivenByTimeStep = fpCurrentProcess;
                     }
                 }
                 else
                 {
                     fpState->fPhysicalStep = fPhysIntLength;
                     fpState->fStepStatus = fPostStepDoItProc;
                     fPostStepDoItProcTriggered = G4int(np);
                     fpStep->GetPostStepPoint()
                             ->SetProcessDefinedStep(fpCurrentProcess);
                 }
             }
         }
     }
 
     // GPIL for AlongStep
     fpState->proposedSafety = DBL_MAX;
     G4double safetyProposedToAndByProcess = fpState->proposedSafety;
 
     for(size_t kp=0; kp < fpProcessInfo->MAXofAlongStepLoops; kp++)
     {
         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAlongStepGetPhysIntVector)[kp];
         if (fpCurrentProcess== 0) continue;
         // NULL means the process is inactivated by a user on fly.
 
         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
         fPhysIntLength = fpCurrentProcess-> AlongStepGPIL( *fpTrack,
                                                            fpState->fPreviousStepSize,
                                                            fpState->fPhysicalStep,
                                                            safetyProposedToAndByProcess,
                                                            &fGPILSelection );
 
         if(fPhysIntLength < fpState->fPhysicalStep)
         {
             fpState->fPhysicalStep  = fPhysIntLength;
             // Should save PS and TS in IT
 
             // Check if the process wants to be the GPIL winner. For example,
             // multi-scattering proposes Step limit, but won't be the winner.
             if(fGPILSelection==CandidateForSelection)
             {
                 fpState->fStepStatus = fAlongStepDoItProc;
                 fpStep->GetPostStepPoint()
                         ->SetProcessDefinedStep(fpCurrentProcess);
             }
 
             // Transportation is assumed to be the last process in the vector
             if(kp == fpProcessInfo->MAXofAlongStepLoops-1)
             {
                 fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
 
                 if(! fpTransportation)
                 {
                     G4ExceptionDescription exceptionDescription ;
                     exceptionDescription << "No transportation process found " ;
                     G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength","ITStepProcessor0009",
                                 FatalErrorInArgument,exceptionDescription);
                 }
 
                 fTimeStep       = fpTransportation->GetInteractionTimeLeft();
 
 
                 if (fpTrack->GetNextVolume() != 0)
                     fpState->fStepStatus = fGeomBoundary;
                 else
                     fpState->fStepStatus = fWorldBoundary;
             }
         }
         else
         {
             if(kp == fpProcessInfo->MAXofAlongStepLoops-1)
             {
                 fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
 
                 if(! fpTransportation)
                 {
                     G4ExceptionDescription exceptionDescription ;
                     exceptionDescription << "No transportation process found " ;
                     G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength","ITStepProcessor0010",
                                 FatalErrorInArgument,exceptionDescription);
                 }
 
                 fTimeStep       = fpTransportation->GetInteractionTimeLeft();
             }
         }
 
         if(proposedTimeStep < fTimeStep)
         {
             if(fPostStepAtTimeDoItProcTriggered<fpProcessInfo->MAXofPostStepLoops)
             {
                 if ((fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] ==
                         InActivated)
                 {
                     (fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] = NotForced;
                     //                    (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] = InActivated;
 
                     fpState->fStepStatus = fPostStepDoItProc;
                     fpStep->GetPostStepPoint()->SetProcessDefinedStep(processWithPostStepGivenByTimeStep);
 
                     fTimeStep = proposedTimeStep;
 
                     fpTransportation->ComputeStep(*fpTrack,*fpStep,fTimeStep,fpState->fPhysicalStep);
                 }
             }
         }
         else
         {
             if (fPostStepDoItProcTriggered<fpProcessInfo->MAXofPostStepLoops)
             {
                 if ((fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] ==
                         InActivated)
                 {
                     (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] =
                             NotForced;
                 }
             }
         }
 
         fpCurrentProcess->SetProcessState(0);
 
         // Make sure to check the safety, even if Step is not limited
         //  by this process.                      J. Apostolakis, June 20, 1998
         //
         if (safetyProposedToAndByProcess < fpState->proposedSafety)
             // proposedSafety keeps the smallest value:
             fpState->proposedSafety               = safetyProposedToAndByProcess;
         else
             // safetyProposedToAndByProcess always proposes a valid safety:
             safetyProposedToAndByProcess = fpState->proposedSafety;
 
     }
 
     fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
     fpNavigator->SetNavigatorState(0);
 }

void G4ITStepProcessor::DoIt	(	G4Track *	,
		double
	)

void G4ITStepProcessor::DoStepping ( )

protected

Definition at line 107 of file G4ITStepProcessor2.cc.

References G4Track::AddTrackLength(), G4ITTrackingManager::AppendStep(), FatalErrorInArgument, fAtRestDoItProc, FindTransportationStep(), fPostStepDoItProc, fStopAndKill, fStopButAlive, fUndefined, G4endl, G4Exception(), G4Track::GetDefinition(), GetIT(), G4Track::GetMomentumDirection(), G4ITNavigator::GetNavigatorState(), G4TrackingInformation::GetNavigatorState(), G4ParticleDefinition::GetParticleName(), G4StepPoint::GetPosition(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetStepLength(), G4Track::GetTouchableHandle(), G4Track::GetTrackID(), G4IT::GetTrackingInfo(), G4Track::GetTrackStatus(), G4Track::IncrementCurrentStepNumber(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePostStepDoItProcs(), InvokeTransportationProc(), G4TrackingInformation::IsLeadingStep(), G4INCL::Math::max(), G4ITNavigator::ResetHierarchyAndLocate(), G4ITNavigator::SetNavigatorState(), G4TrackingInformation::SetNavigatorState(), G4StepPoint::SetProcessDefinedStep(), G4StepPoint::SetSafety(), G4Step::SetStepLength(), G4Track::SetStepLength(), G4StepPoint::SetStepStatus(), G4Track::SetTrackStatus(), and SetupMembers().

Referenced by Stepping().

 {
     SetupMembers() ;
 
     if(!fpProcessInfo)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "No process info found for particle :"
                              << fpTrack->GetDefinition()->GetParticleName();
         G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0012",
                     FatalErrorInArgument,exceptionDescription);
         return ;
     }
     else if(fpTrack->GetTrackStatus() == fStopAndKill )
     {
         fpState->fStepStatus = fUndefined;
         return ;
     }
 
     if(fpProcessInfo->MAXofPostStepLoops == 0
             && fpProcessInfo->MAXofAlongStepLoops == 0
             && fpProcessInfo->MAXofAtRestLoops == 0)
     {
         fpTrack -> SetTrackStatus(fStopAndKill) ;
         fpState->fStepStatus = fUndefined;
         return ;
     }
     //---------------------------------
     // AtRestStep, AlongStep and PostStep Processes
     //---------------------------------
     else
     {
         fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
         fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
                                               fpTrack->GetMomentumDirection(),
                                               *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
         fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
         // We reset the navigator state before checking for AtRest
         // in case a AtRest processe would use a navigator info
 
         if( fpTrack->GetTrackStatus() == fStopButAlive )
         {
             if( fpProcessInfo->MAXofAtRestLoops>0 &&
                     fpProcessInfo->fpAtRestDoItVector != 0) // second condition to make coverity happy
             {
                 //-----------------
                 // AtRestStepDoIt
                 //-----------------
                 InvokeAtRestDoItProcs();
                 fpState->fStepStatus = fAtRestDoItProc;
                 fpStep->GetPostStepPoint()->SetStepStatus( fpState->fStepStatus );
 
             }
             // Make sure the track is killed
             fpTrack->SetTrackStatus( fStopAndKill );
         }
         else // if(fTimeStep > 0.) // Bye, because PostStepIL can return 0 => time =0
         {
             if(fpITrack == 0)
             {
                 G4ExceptionDescription exceptionDescription ;
                 exceptionDescription
                         << " !!! TrackID : "<<  fpTrack->GetTrackID() << G4endl
                         << " !!! Track status : "<<  fpTrack->GetTrackStatus() << G4endl
                         << " !!! Particle Name : "<< fpTrack -> GetDefinition() -> GetParticleName() << G4endl
                         << "No G4ITStepProcessor::fpITrack found" << G4endl;
 
                 G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0013",
                             FatalErrorInArgument,exceptionDescription);
                 return ; // to make coverity happy
             }
 
             if(fpITrack->GetTrackingInfo()->IsLeadingStep() == false)
             {
                 // In case the track has NOT the minimum step length
                 // Given the final step time, the transportation
                 // will compute the final position of the particle
 
                 fpState->fStepStatus = fPostStepDoItProc;
                 fpStep->GetPostStepPoint()
                         ->SetProcessDefinedStep(fpTransportation);
                 FindTransportationStep();
             }
 
 
             // Store the Step length (geometrical length) to G4Step and G4Track
             fpTrack->SetStepLength( fpState->fPhysicalStep );
             fpStep->SetStepLength( fpState->fPhysicalStep );
 
             G4double GeomStepLength = fpState->fPhysicalStep;
 
             // Store StepStatus to PostStepPoint
             fpStep->GetPostStepPoint()->SetStepStatus( fpState->fStepStatus );
 
             // Invoke AlongStepDoIt
             InvokeAlongStepDoItProcs();
 
             // Update track by taking into account all changes by AlongStepDoIt
             // fpStep->UpdateTrack(); // done in InvokeAlongStepDoItProcs
 
             // Update safety after invocation of all AlongStepDoIts
             fpState->endpointSafOrigin= fpPostStepPoint->GetPosition();
 
             fpState->endpointSafety=  std::max( fpState->proposedSafety - GeomStepLength, kCarTolerance);
 
             fpStep->GetPostStepPoint()->SetSafety( fpState->endpointSafety );
 
             if(GetIT(fpTrack)->GetTrackingInfo()->IsLeadingStep())
             {
                 // Invoke PostStepDoIt including G4ITTransportation::PSDI
                 InvokePostStepDoItProcs();
             }
             else
             {
                 // Only invoke transportation
                 InvokeTransportationProc();
             }
         }
 
         fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
         fpNavigator->SetNavigatorState(0);
     }
     //-------
     // Finale
     //-------
 
     // Update 'TrackLength' and remeber the Step length of the current Step
     fpTrack->AddTrackLength(fpStep->GetStepLength());
     fpTrack->IncrementCurrentStepNumber();
 
     // Send G4Step information to Hit/Dig if the volume is sensitive
 /***
     fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
     StepControlFlag =  fpStep->GetControlFlag();
 
     if( fpCurrentVolume != 0 && StepControlFlag != AvoidHitInvocation)
     {
         fpSensitive = fpStep->GetPreStepPoint()->
                 GetSensitiveDetector();
         if( fpSensitive != 0 )
         {
             fpSensitive->Hit(fpStep);
         }
     }
 
      User intervention process.
     if( fpUserSteppingAction != 0 )
     {
         fpUserSteppingAction->UserSteppingAction(fpStep);
     }
     G4UserSteppingAction* regionalAction
             = fpStep->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()
             ->GetRegionalSteppingAction();
     if( regionalAction ) regionalAction->UserSteppingAction(fpStep);
 ***/
     fpTrackingManager->AppendStep(fpTrack,fpStep);
     // Stepping process finish. Return the value of the StepStatus.
 
     //    return fpState->fStepStatus;
 }

void G4ITStepProcessor::FindTransportationStep ( )

Definition at line 463 of file G4ITStepProcessor2.cc.

References G4ITTransportation::ComputeStep(), DBL_MAX, FatalErrorInArgument, fStopAndKill, G4Exception(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4IT::GetTrack(), and G4VITProcess::SetProcessState().

Referenced by DoStepping().

 {
     double physicalStep(0.) ;
 
     fpTransportation =  fpProcessInfo->fpTransportation;
     //            dynamic_cast<G4ITTransportation*>((fpProcessInfo->fpAlongStepGetPhysIntVector)[MAXofAlongStepLoops-1]);
 
     if(!fpTrack)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription
                 << "No G4ITStepProcessor::fpTrack found";
         G4Exception("G4ITStepProcessor::FindTransportationStep","ITStepProcessor0013",
                     FatalErrorInArgument,exceptionDescription);
         return;
 
     }
     if(!fpITrack)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription
                 << "No G4ITStepProcessor::fITrack" ;
         G4Exception("G4ITStepProcessor::FindTransportationStep","ITStepProcessor0014",
                     FatalErrorInArgument,exceptionDescription);
         return;
     }
     if(!(fpITrack->GetTrack()))
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription
                 << "No G4ITStepProcessor::fITrack->GetTrack()" ;
         G4Exception("G4ITStepProcessor::FindTransportationStep","ITStepProcessor0015",
                     FatalErrorInArgument,exceptionDescription);
         return;
     }
 
     if(fpTransportation)
     {
         fpTransportation->SetProcessState(fpTrackingInfo->GetProcessState(fpTransportation->GetProcessID()));
         fpTransportation->ComputeStep(*fpTrack, *fpStep, fTimeStep, physicalStep) ;
         fpTransportation->SetProcessState(0);
     }
 
     if(physicalStep >= DBL_MAX)
     {
         fpTrack -> SetTrackStatus(fStopAndKill) ;
         return ;
     }
 
     fpState->fPhysicalStep = physicalStep ;
 }

void G4ITStepProcessor::ForceReInitialization ( )

Definition at line 164 of file G4ITStepProcessor.cc.

References ClearProcessInfo(), and Initialize().

 {
     fInitialized = false;
     ClearProcessInfo();
     Initialize();
 }

void G4ITStepProcessor::GetAtRestIL ( )

protected

Definition at line 459 of file G4ITStepProcessor.cc.

References G4VProcess::AtRestGPIL(), DBL_MAX, Forced, G4cerr, G4endl, G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), InActivated, NotForced, and G4VITProcess::SetProcessState().

Referenced by DoDefinePhysicalStepLength().

 {
     // Select the rest process which has the shortest time before
     // it is invoked. In rest processes, GPIL()
     // returns the time before a process occurs.
     G4double lifeTime (DBL_MAX), shortestLifeTime (DBL_MAX);
 
     fAtRestDoItProcTriggered = 0;
     shortestLifeTime = DBL_MAX;
 
     unsigned int NofInactiveProc=0;
 
     for( size_t ri=0 ; ri < fpProcessInfo->MAXofAtRestLoops ; ri++ )
     {
         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAtRestGetPhysIntVector)[ri];
         if (fpCurrentProcess== 0)
         {
             (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
             NofInactiveProc++;
             continue;
         }   // NULL means the process is inactivated by a user on fly.
 
         fCondition=NotForced;
         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
         lifeTime = fpCurrentProcess->AtRestGPIL( *fpTrack, &fCondition );
         fpCurrentProcess->SetProcessState(0);
 
         if(fCondition==Forced)
         {
             (fpState->fSelectedAtRestDoItVector)[ri] = Forced;
         }
         else
         {
             (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
             if(lifeTime < shortestLifeTime )
             {
                 shortestLifeTime = lifeTime;
                 fAtRestDoItProcTriggered =  G4int(ri);
                 (fpState->fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
             }
         }
     }
 
     fTimeStep = shortestLifeTime ;
 
     // at least one process is necessary to destroy the particle
     // exit with warning
     if(NofInactiveProc==fpProcessInfo->MAXofAtRestLoops)
     {
         G4cerr << "ERROR - G4ITStepProcessor::InvokeAtRestDoItProcs()" << G4endl
                << "        No AtRestDoIt process is active!" << G4endl;
     }
 }

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 359 of file G4ITStepProcessor.hh.

 {
     return fTimeStep ;
 }

void G4ITStepProcessor::GetProcessInfo ( )

protected

Definition at line 414 of file G4ITStepProcessor.cc.

References FatalErrorInArgument, G4Exception(), G4Track::GetDefinition(), G4ParticleDefinition::GetProcessManager(), and SetupGeneralProcessInfo().

Referenced by SetupMembers().

 {
     G4ParticleDefinition* particle = fpTrack->GetDefinition();
     std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it = fProcessGeneralInfoMap.find(particle);
 
     if(it == fProcessGeneralInfoMap.end())
     {
         SetupGeneralProcessInfo(particle,fpTrack->GetDefinition()->GetProcessManager());
         if(fpProcessInfo == 0)
         {
             G4ExceptionDescription exceptionDescription ("...");
             G4Exception("G4ITStepProcessor::GetProcessNumber","ITStepProcessor0008",
                         FatalErrorInArgument,exceptionDescription);
             return;
         }
     }
     else
     {
         fpProcessInfo = it->second;
     }
 }

G4TrackVector* G4ITStepProcessor::GetSecondaries ( )

inline

Definition at line 97 of file G4ITStepProcessor.hh.

97 {return fpSecondary;}

G4Step* G4ITStepProcessor::GetStep ( )

inline

Definition at line 93 of file G4ITStepProcessor.hh.

Referenced by SetTrack().

93 {return fpStep;}

const G4Step* G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 94 of file G4ITStepProcessor.hh.

94 {return fpStep;}

G4Track* G4ITStepProcessor::GetTrack ( )

inline

Definition at line 92 of file G4ITStepProcessor.hh.

92 {return fpTrack;}

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 309 of file G4ITStepProcessor.hh.

 {
     return fpTrack;
 }

G4ITTrackingManager* G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 99 of file G4ITStepProcessor.hh.

99 {return fpTrackingManager;}

void G4ITStepProcessor::InitDefineStep ( )

protected

Definition at line 617 of file G4ITStepProcessor.cc.

References G4Step::CopyPostToPreStepPoint(), G4ITNavigator::CreateTouchableHistory(), G4Track::GetMomentumDirection(), G4TrackingInformation::GetNavigatorState(), G4Track::GetNextTouchableHandle(), G4StepPoint::GetPhysicalVolume(), G4Track::GetPosition(), G4Step::GetPreStepPoint(), G4VPhysicalVolume::GetRegularStructureId(), G4Track::GetStepLength(), G4Track::GetTouchableHandle(), G4IT::GetTrackingInfo(), G4VTouchable::GetVolume(), G4ITNavigator::NewNavigatorState(), G4Step::NewSecondaryVector(), G4ITNavigator::ResetHierarchyAndLocate(), G4Step::ResetTotalEnergyDeposit(), SetInitialStep(), G4ITNavigator::SetNavigatorState(), G4Track::SetNextTouchableHandle(), G4Step::SetPointerToVectorOfAuxiliaryPoints(), G4Track::SetStep(), G4TrackingInformation::SetStepProcessorState(), G4Track::SetTouchableHandle(), and SetupMembers().

Referenced by DoDefinePhysicalStepLength().

 {
 
     if(!fpStep)
     {
 
         // Create new Step and give it to the track
         fpStep = new G4Step();
         fpTrack->SetStep(fpStep);
         fpSecondary = fpStep->NewSecondaryVector();
 
         // Create new state and set it in the trackingInfo
         fpState = new G4ITStepProcessorState();
         fpITrack->GetTrackingInfo()->SetStepProcessorState((G4ITStepProcessorState_Lock*)fpState);
 
         SetupMembers();
         fpNavigator->NewNavigatorState();
 
         SetInitialStep();
     }
     else
     {
         SetupMembers();
 
         fpState->fPreviousStepSize = fpTrack->GetStepLength();
 /***
         // Send G4Step information to Hit/Dig if the volume is sensitive
         fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
         StepControlFlag =  fpStep->GetControlFlag();
         if( fpCurrentVolume != 0 && StepControlFlag != AvoidHitInvocation)
         {
             fpSensitive = fpStep->GetPreStepPoint()->
                     GetSensitiveDetector();
 
             //            if( fSensitive != 0 ) {
             //              fSensitive->Hit(fStep);
             //            }
         }
 ***/
         // Store last PostStepPoint to PreStepPoint, and swap current and next
         // volume information of G4Track. Reset total energy deposit in one Step.
         fpStep->CopyPostToPreStepPoint();
         fpStep->ResetTotalEnergyDeposit();
 
         //JA Set the volume before it is used (in DefineStepLength() for User Limit)
         fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
 /*
         G4cout << G4endl;
         G4cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
         G4cout << "PreStepPoint Volume : " << fpCurrentVolume->GetName() << G4endl;
         G4cout << "Track Touchable : " << fpTrack->GetTouchableHandle()->GetVolume()->GetName() << G4endl;
         G4cout << "Track NextTouchable : " << fpTrack->GetNextTouchableHandle()->GetVolume()->GetName() << G4endl;
 */
         // Reset the step's auxiliary points vector pointer
         fpStep->SetPointerToVectorOfAuxiliaryPoints(0);
 
         // Switch next touchable in track to current one
         fpTrack->SetTouchableHandle(fpTrack->GetNextTouchableHandle());
         fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
         fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
         G4VPhysicalVolume* oldTopVolume= fpTrack->GetTouchableHandle()->GetVolume();
         fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
 
         G4VPhysicalVolume* newTopVolume=
                 fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
                                                       fpTrack->GetMomentumDirection(),
                                                       *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
 
         //        G4cout << "New Top Volume : " << newTopVolume->GetName() << G4endl;
 
         if(newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId() == 1 )
         {
             fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
             fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
             fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
         }
 
         fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
     }
 }

void G4ITStepProcessor::Initialize ( )

virtual

Definition at line 173 of file G4ITStepProcessor.cc.

References CleanProcessor(), DBL_MAX, G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), G4ITTransportationManager::GetTransportationManager(), and SetNavigator().

Referenced by ForceReInitialization().

 {
     CleanProcessor();
     if(fInitialized) return;
     //    ActiveOnlyITProcess();
 
     SetNavigator(G4ITTransportationManager::GetTransportationManager()
                  ->GetNavigatorForTracking());
 
     fPhysIntLength = DBL_MAX;
     kCarTolerance = 0.5*G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
     fInitialized = true;
 }

void G4ITStepProcessor::InvokeAlongStepDoItProcs ( )

protected

Definition at line 324 of file G4ITStepProcessor2.cc.

References G4VProcess::AlongStepDoIt(), G4VParticleChange::Clear(), DBL_MIN, DealWithSecondaries(), fAlive, fExclusivelyForcedProc, fStopAndKill, fStopButAlive, G4Track::GetKineticEnergy(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4VParticleChange::GetTrackStatus(), G4Track::GetTrackStatus(), G4VITProcess::SetProcessState(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForAlongStep(), and G4Step::UpdateTrack().

Referenced by DoStepping().

 {
 
     // If the current Step is defined by a 'ExclusivelyForced'
     // PostStepDoIt, then don't invoke any AlongStepDoIt
     if(fpState->fStepStatus == fExclusivelyForcedProc)
     {
         return;               // Take note 'return' at here !!!
     }
 
     // Invoke the all active continuous processes
     for( size_t ci=0 ; ci<fpProcessInfo->MAXofAlongStepLoops ; ci++ )
     {
         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAlongStepDoItVector)[ci];
         if (fpCurrentProcess== 0) continue;
         // NULL means the process is inactivated by a user on fly.
 
         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
         fpParticleChange
                 = fpCurrentProcess->AlongStepDoIt( *fpTrack, *fpStep );
         fpCurrentProcess->SetProcessState(0);
         // Update the PostStepPoint of Step according to ParticleChange
 
         fpParticleChange->UpdateStepForAlongStep(fpStep);
 
         // Now Store the secondaries from ParticleChange to SecondaryList
         DealWithSecondaries(fN2ndariesAlongStepDoIt) ;
 
         // Set the track status according to what the process defined
         // if kinetic energy >0, otherwise set  fStopButAlive
         fpTrack->SetTrackStatus( fpParticleChange->GetTrackStatus() );
 
         // clear ParticleChange
         fpParticleChange->Clear();
     }
 
     fpStep->UpdateTrack();
 
     G4TrackStatus fNewStatus = fpTrack->GetTrackStatus();
 
     if ( fNewStatus == fAlive && fpTrack->GetKineticEnergy() <= DBL_MIN )
     {
         //        G4cout << "G4ITStepProcessor::InvokeAlongStepDoItProcs : Track will be killed" << G4endl;
         if(fpProcessInfo->MAXofAtRestLoops>0) fNewStatus = fStopButAlive;
         else                   fNewStatus = fStopAndKill;
         fpTrack->SetTrackStatus( fNewStatus );
     }
 
 }

void G4ITStepProcessor::InvokeAtRestDoItProcs ( )

protected

Definition at line 274 of file G4ITStepProcessor2.cc.

References G4VProcess::AtRestDoIt(), G4VParticleChange::Clear(), DealWithSecondaries(), fStopAndKill, G4Step::GetPostStepPoint(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), InActivated, G4StepPoint::SetProcessDefinedStep(), G4VITProcess::SetProcessState(), G4Step::SetStepLength(), G4Track::SetStepLength(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForAtRest(), and G4Step::UpdateTrack().

Referenced by DoStepping().

 {
     fpStep->SetStepLength( 0. );  //the particle has stopped
     fpTrack->SetStepLength( 0. );
 
     G4SelectedAtRestDoItVector& selectedAtRestDoItVector = fpState->fSelectedAtRestDoItVector;
 
     // invoke selected process
     for(size_t np=0; np < fpProcessInfo->MAXofAtRestLoops; np++)
     {
         //
         // Note: DoItVector has inverse order against GetPhysIntVector
         //       and SelectedAtRestDoItVector.
         //
         if( selectedAtRestDoItVector[fpProcessInfo->MAXofAtRestLoops-np-1] != InActivated)
         {
             fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAtRestDoItVector)[np];
 
             fpCurrentProcess->SetProcessState(
                         fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
             fpParticleChange
                     = fpCurrentProcess->AtRestDoIt( *fpTrack, *fpStep);
             fpCurrentProcess->SetProcessState(0);
 
             // Set the current process as a process which defined this Step length
             fpStep->GetPostStepPoint()
                     ->SetProcessDefinedStep(fpCurrentProcess);
 
             // Update Step
             fpParticleChange->UpdateStepForAtRest(fpStep);
 
             // Now Store the secondaries from ParticleChange to SecondaryList
             DealWithSecondaries(fN2ndariesAtRestDoIt) ;
 
             // clear ParticleChange
             fpParticleChange->Clear();
 
         } //if(fSelectedAtRestDoItVector[np] != InActivated){
     } //for(size_t np=0; np < MAXofAtRestLoops; np++){
     fpStep->UpdateTrack();
 
     fpTrack->SetTrackStatus( fStopAndKill );
 }

void G4ITStepProcessor::InvokePostStepDoItProcs ( )

protected

Definition at line 382 of file G4ITStepProcessor2.cc.

References ExclusivelyForced, fExclusivelyForcedProc, Forced, fPostStepDoItProc, fStopAndKill, G4Track::GetTrackStatus(), InActivated, InvokePSDIP(), NotForced, and StronglyForced.

Referenced by DoStepping().

 {
 
     G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState->fSelectedPostStepDoItVector;
     G4StepStatus& stepStatus = fpState->fStepStatus;
 
     // Invoke the specified discrete processes
     for(size_t np=0; np < fpProcessInfo->MAXofPostStepLoops; np++)
     {
         //
         // Note: DoItVector has inverse order against GetPhysIntVector
         //       and SelectedPostStepDoItVector.
         //
         G4int Cond = selectedPostStepDoItVector[fpProcessInfo->MAXofPostStepLoops-np-1];
         if(Cond != InActivated)
         {
             if( ((Cond == NotForced) && (stepStatus == fPostStepDoItProc)) ||
                     ((Cond == Forced) && (stepStatus != fExclusivelyForcedProc)) ||
                     //                    ((Cond == Conditionally) && (stepStatus == fAlongStepDoItProc)) ||
                     ((Cond == ExclusivelyForced) && (stepStatus == fExclusivelyForcedProc)) ||
                     ((Cond == StronglyForced) )
                     )
             {
 
                 InvokePSDIP(np);
             }
         } //if(*fSelectedPostStepDoItVector(np)........
 
         // Exit from PostStepLoop if the track has been killed,
         // but extra treatment for processes with Strongly Forced flag
         if(fpTrack->GetTrackStatus() == fStopAndKill)
         {
             for(size_t np1=np+1; np1 < fpProcessInfo->MAXofPostStepLoops; np1++)
             {
                 G4int Cond2 = selectedPostStepDoItVector[fpProcessInfo->MAXofPostStepLoops-np1-1];
                 if (Cond2 == StronglyForced)
                 {
                     InvokePSDIP(np1);
                 }
             }
             break;
         }
     } //for(size_t np=0; np < MAXofPostStepLoops; np++){
 }

void G4ITStepProcessor::InvokePSDIP ( size_t np )

protected

Definition at line 429 of file G4ITStepProcessor2.cc.

References CalculateSafety(), G4VParticleChange::Clear(), DealWithSecondaries(), G4Step::GetPostStepPoint(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4VParticleChange::GetTrackStatus(), G4VProcess::PostStepDoIt(), G4VITProcess::SetProcessState(), G4StepPoint::SetSafety(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForPostStep(), and G4Step::UpdateTrack().

Referenced by InvokePostStepDoItProcs(), and InvokeTransportationProc().

 {
     fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepDoItVector)[np];
 
     fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
     fpParticleChange
             = fpCurrentProcess->PostStepDoIt( *fpTrack, *fpStep);
     fpCurrentProcess->SetProcessState(0);
 
     // Update PostStepPoint of Step according to ParticleChange
     fpParticleChange->UpdateStepForPostStep(fpStep);
 
     // Update G4Track according to ParticleChange after each PostStepDoIt
     fpStep->UpdateTrack();
 
     // Update safety after each invocation of PostStepDoIts
     fpStep->GetPostStepPoint()->SetSafety( CalculateSafety() );
 
     // Now Store the secondaries from ParticleChange to SecondaryList
     DealWithSecondaries(fN2ndariesPostStepDoIt) ;
 
     // Set the track status according to what the process defined
     fpTrack->SetTrackStatus( fpParticleChange->GetTrackStatus() );
 
     // clear ParticleChange
     fpParticleChange->Clear();
 }

void G4ITStepProcessor::InvokeTransportationProc ( )

protected

Definition at line 517 of file G4ITStepProcessor2.cc.

References ExclusivelyForced, fExclusivelyForcedProc, Forced, fStopAndKill, G4Track::GetTrackStatus(), InActivated, InvokePSDIP(), and StronglyForced.

Referenced by DoStepping().

 {
     size_t _MAXofPostStepLoops = fpProcessInfo->MAXofPostStepLoops;
     G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState->fSelectedPostStepDoItVector;
     G4StepStatus& stepStatus = fpState->fStepStatus;
 
     // Invoke the specified discrete processes
     for(size_t np=0; np < _MAXofPostStepLoops; np++)
     {
         //
         // Note: DoItVector has inverse order against GetPhysIntVector
         //       and SelectedPostStepDoItVector.
         //
         G4int Cond = selectedPostStepDoItVector[_MAXofPostStepLoops-np-1];
         if(Cond != InActivated)
         {
             if(
                     ((Cond == Forced) && (stepStatus != fExclusivelyForcedProc)) ||
                     //                ((Cond == Conditionally) && (stepStatus == fAlongStepDoItProc)) ||
                     ((Cond == ExclusivelyForced) && (stepStatus == fExclusivelyForcedProc)) ||
                     ((Cond == StronglyForced) )
                     )
             {
 
                 InvokePSDIP(np);
             }
         } //if(*fSelectedPostStepDoItVector(np)........
 
         // Exit from PostStepLoop if the track has been killed,
         // but extra treatment for processes with Strongly Forced flag
         if(fpTrack->GetTrackStatus() == fStopAndKill)
         {
             for(size_t np1=np+1; np1 < _MAXofPostStepLoops; np1++)
             {
                 G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops-np1-1];
                 if (Cond2 == StronglyForced)
                 {
                     InvokePSDIP(np1);
                 }
             }
             break;
         }
     }
 }

G4ITStepProcessor & G4ITStepProcessor::operator= ( const G4ITStepProcessor & other )

protected

Definition at line 224 of file G4ITStepProcessor.cc.

 {
     if (this == &rhs) return *this; // handle self assignment
     //assignment operator
     return *this;
 }

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 450 of file G4ITStepProcessor.cc.

Referenced by G4ITStepProcessor(), and SetupMembers().

 {
     // Reset the secondary particles
     fN2ndariesAtRestDoIt    = 0;
     fN2ndariesAlongStepDoIt = 0;
     fN2ndariesPostStepDoIt  = 0;
 }

void G4ITStepProcessor::SetInitialStep ( )

protected

Definition at line 522 of file G4ITStepProcessor.cc.

References G4ITNavigator::CreateTouchableHistory(), fAlive, FatalException, fPostponeToNextEvent, fStopAndKill, fStopButAlive, fSuspend, fUndefined, G4cerr, G4cout, G4endl, G4Exception(), G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4Track::GetMomentumDirection(), G4Track::GetParentID(), G4Track::GetPosition(), G4VPhysicalVolume::GetRegularStructureId(), G4Track::GetTouchableHandle(), G4Track::GetTrackStatus(), G4VTouchable::GetVolume(), G4Track::GetVolume(), G4Step::InitializeStep(), G4ITNavigator::LocateGlobalPointAndSetup(), G4ITNavigator::ResetHierarchyAndLocate(), G4Track::SetLogicalVolumeAtVertex(), G4Track::SetNextTouchableHandle(), G4Track::SetTouchableHandle(), G4Track::SetTrackStatus(), G4Track::SetVertexKineticEnergy(), G4Track::SetVertexMomentumDirection(), G4Track::SetVertexPosition(), and G4ITTrackingManager::StartTracking().

Referenced by InitDefineStep().

 {
     // DEBUG
     //    G4cout << "SetInitialStep for : " << fpITrack-> GetName() << G4endl;
     //________________________________________________________
     // Initialize geometry
 
 
     if ( ! fpTrack->GetTouchableHandle())
     {
         G4ThreeVector direction= fpTrack->GetMomentumDirection();
         fpNavigator->LocateGlobalPointAndSetup( fpTrack->GetPosition(),
                                                 &direction, false, false );
         fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
 
         fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
         fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
     }
     else
     {
         fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
         fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
         G4VPhysicalVolume* oldTopVolume= fpTrack->GetTouchableHandle()->GetVolume();
         G4VPhysicalVolume* newTopVolume=
                 fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
                                                       fpTrack->GetMomentumDirection(),
                                                       *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
         if(newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId() == 1 )
         {
             fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
             fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
             fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
         }
     }
 
     fpCurrentVolume = fpState->fTouchableHandle->GetVolume();
 
     //________________________________________________________
     // If the primary track has 'Suspend' or 'PostponeToNextEvent' state,
     // set the track state to 'Alive'.
     if( (fpTrack->GetTrackStatus()==fSuspend) ||
             (fpTrack->GetTrackStatus()==fPostponeToNextEvent) )
     {
         fpTrack->SetTrackStatus(fAlive);
     }
 
     // If the primary track has 'zero' kinetic energy, set the track
     // state to 'StopButAlive'.
     if(fpTrack->GetKineticEnergy() <= 0.0)
     {
         fpTrack->SetTrackStatus( fStopButAlive );
     }
     //________________________________________________________
     // Set vertex information of G4Track at here
     if ( fpTrack->GetCurrentStepNumber() == 0 )
     {
         fpTrack->SetVertexPosition( fpTrack->GetPosition() );
         fpTrack->SetVertexMomentumDirection( fpTrack->GetMomentumDirection() );
         fpTrack->SetVertexKineticEnergy( fpTrack->GetKineticEnergy() );
         fpTrack->SetLogicalVolumeAtVertex( fpTrack->GetVolume()->GetLogicalVolume() );
     }
     //________________________________________________________
     // If track is already outside the world boundary, kill it
     if( fpCurrentVolume==0 )
     {
         // If the track is a primary, stop processing
         if(fpTrack->GetParentID()==0)
         {
             G4cerr << "ERROR - G4ITStepProcessor::SetInitialStep()" << G4endl
                    << "        Primary particle starting at - "
                    << fpTrack->GetPosition()
                    << " - is outside of the world volume." << G4endl;
             G4Exception("G4ITStepProcessor::SetInitialStep()", "ITStepProcessor0011",
                         FatalException, "Primary vertex outside of the world!");
         }
 
         fpTrack->SetTrackStatus( fStopAndKill );
         G4cout << "WARNING - G4ITStepProcessor::SetInitialStep()" << G4endl
                << "          Initial track position is outside world! - "
                << fpTrack->GetPosition() << G4endl;
     }
     else{
         // Initial set up for attribues of 'Step'
         fpStep->InitializeStep( fpTrack );
     }
 
 
     if( fpTrack->GetTrackStatus() == fStopAndKill ) return ;
 
     fpTrackingManager->StartTracking(fpTrack);
 
     fpState->fStepStatus = fUndefined;
 }

void G4ITStepProcessor::SetNavigator ( G4ITNavigator * value )

inlineprotected

Definition at line 321 of file G4ITStepProcessor.hh.

Referenced by Initialize().

 {
     fpNavigator = value;
 }

void G4ITStepProcessor::SetPreviousStepTime ( G4double previousTimeStep )

inline

Definition at line 304 of file G4ITStepProcessor.hh.

 {
     fPreviousTimeStep = previousTimeStep;
 }

void G4ITStepProcessor::SetStep ( G4Step * val )

inline

Definition at line 95 of file G4ITStepProcessor.hh.

95 {fpStep = val;}

void G4ITStepProcessor::SetTrack ( G4Track * track )

protected

Definition at line 384 of file G4ITStepProcessor.cc.

References FatalErrorInArgument, G4cerr, G4endl, G4Exception(), GetIT(), GetStep(), G4Track::GetTrackID(), and G4IT::GetTrackingInfo().

Referenced by DefinePhysicalStepLength(), and Stepping().

 {
     fpTrack = track ;
     if(fpTrack)
     {
         fpITrack = GetIT(fpTrack) ;
         fpStep = const_cast<G4Step*>(fpTrack -> GetStep());
 
         if(fpITrack)
         {
             fpTrackingInfo = fpITrack->GetTrackingInfo() ;
         }
         else
         {
             fpTrackingInfo = 0;
             G4cerr << "Track ID : " << fpTrack->GetTrackID() << G4endl;
 
             G4ExceptionDescription exceptionDescription ("No IT pointer was attached to the track you try to process.");
             G4Exception("G4ITStepProcessor::SetTrack","ITStepProcessor0007",
                         FatalErrorInArgument,exceptionDescription);
         }
     }
     else
     {
         fpITrack = 0;
         fpStep = 0 ;
     }
 }

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager * trackMan )

inline

Definition at line 98 of file G4ITStepProcessor.hh.

98 {fpTrackingManager = trackMan;}

void G4ITStepProcessor::SetupGeneralProcessInfo	(	G4ParticleDefinition *	particle,
		G4ProcessManager *	pm
	)

protected

Definition at line 283 of file G4ITStepProcessor.cc.

References G4ProcessVector::entries(), FatalErrorInArgument, FatalException, G4cerr, G4cout, G4endl, G4Exception(), G4ProcessManager::GetAlongStepProcessVector(), G4ProcessManager::GetAtRestProcessVector(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ProcessManager::GetPostStepProcessVector(), typeDoIt, and typeGPIL.

Referenced by GetProcessInfo().

 {
 
 #ifdef debug
     G4cout<<"G4ITStepProcessor::GetProcessNumber: is called track"<<G4endl;
 #endif
     if(!pm)
     {
         G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
                << "        ProcessManager is NULL for particle = "
                << particle->GetParticleName() << ", PDG_code = "
                << particle->GetPDGEncoding() << G4endl;
         G4Exception("G4SteppingManager::GetProcessNumber()", "ITStepProcessor0002",
                     FatalException, "Process Manager is not found.");
         return;
     }
 
     std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it = fProcessGeneralInfoMap.find(particle);
     if(it != fProcessGeneralInfoMap.end())
     {
         G4Exception("G4SteppingManager::SetupGeneralProcessInfo()", "ITStepProcessor0003",
                     FatalException, "Process info already registered.");
         return;
     }
 
     // here used as temporary
     fpProcessInfo = new ProcessGeneralInfo();
 
     // AtRestDoits
     fpProcessInfo->MAXofAtRestLoops =        pm->GetAtRestProcessVector()->entries();
     fpProcessInfo->fpAtRestDoItVector =       pm->GetAtRestProcessVector(typeDoIt);
     fpProcessInfo->fpAtRestGetPhysIntVector = pm->GetAtRestProcessVector(typeGPIL);
 #ifdef debug
     G4cout << "G4ITStepProcessor::GetProcessNumber: #ofAtRest="
            << fpProcessInfo->MAXofAtRestLoops << G4endl;
 #endif
 
     // AlongStepDoits
     fpProcessInfo->MAXofAlongStepLoops = pm->GetAlongStepProcessVector()->entries();
     fpProcessInfo->fpAlongStepDoItVector = pm->GetAlongStepProcessVector(typeDoIt);
     fpProcessInfo->fpAlongStepGetPhysIntVector = pm->GetAlongStepProcessVector(typeGPIL);
 #ifdef debug
     G4cout << "G4ITStepProcessor::GetProcessNumber:#ofAlongStp="
            << fpProcessInfo->MAXofAlongStepLoops << G4endl;
 #endif
 
     // PostStepDoits
     fpProcessInfo->MAXofPostStepLoops = pm->GetPostStepProcessVector()->entries();
     fpProcessInfo->fpPostStepDoItVector = pm->GetPostStepProcessVector(typeDoIt);
     fpProcessInfo->fpPostStepGetPhysIntVector = pm->GetPostStepProcessVector(typeGPIL);
 #ifdef debug
     G4cout << "G4ITStepProcessor::GetProcessNumber: #ofPostStep="
            << fpProcessInfo->MAXofPostStepLoops << G4endl;
 #endif
 
     if (SizeOfSelectedDoItVector<fpProcessInfo->MAXofAtRestLoops    ||
             SizeOfSelectedDoItVector<fpProcessInfo->MAXofAlongStepLoops ||
             SizeOfSelectedDoItVector<fpProcessInfo->MAXofPostStepLoops  )
     {
         G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
                << "        SizeOfSelectedDoItVector= " << SizeOfSelectedDoItVector
                << " ; is smaller then one of MAXofAtRestLoops= "
                << fpProcessInfo->MAXofAtRestLoops << G4endl
                << "        or MAXofAlongStepLoops= " << fpProcessInfo->MAXofAlongStepLoops
                << " or MAXofPostStepLoops= " << fpProcessInfo->MAXofPostStepLoops << G4endl;
         G4Exception("G4ITStepProcessor::GetProcessNumber()",
                     "ITStepProcessor0004", FatalException,
                     "The array size is smaller than the actual No of processes.");
     }
 
     if(!fpProcessInfo->fpAtRestDoItVector   &&
             !fpProcessInfo->fpAlongStepDoItVector    &&
             !fpProcessInfo->fpPostStepDoItVector)
     {
         G4ExceptionDescription exceptionDescription ;
         exceptionDescription << "No DoIt process found " ;
         G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0005",
                     FatalErrorInArgument,exceptionDescription);
         return ;
     }
 
     if(fpProcessInfo->fpAlongStepGetPhysIntVector && fpProcessInfo->MAXofAlongStepLoops>0)
     {
         fpProcessInfo->fpTransportation = dynamic_cast<G4ITTransportation*>
                 ((*fpProcessInfo->fpAlongStepGetPhysIntVector)[fpProcessInfo->MAXofAlongStepLoops-1]);
 
         if(fpProcessInfo->fpTransportation == 0)
         {
             G4ExceptionDescription exceptionDescription ;
             exceptionDescription << "No transportation process found " ;
             G4Exception("G4ITStepProcessor::SetupGeneralProcessInfo","ITStepProcessor0006",
                         FatalErrorInArgument,exceptionDescription);
         }
     }
     fProcessGeneralInfoMap[particle] = fpProcessInfo;
     //    fpProcessInfo = 0;
 }

void G4ITStepProcessor::SetupMembers ( )

protected

Definition at line 437 of file G4ITStepProcessor.cc.

References G4Step::GetfSecondary(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), GetProcessInfo(), G4TrackingInformation::GetStepProcessorState(), G4IT::GetTrackingInfo(), and ResetSecondaries().

Referenced by DoStepping(), and InitDefineStep().

 {
     fpSecondary      = fpStep->GetfSecondary();
     fpPreStepPoint   = fpStep->GetPreStepPoint();
     fpPostStepPoint  = fpStep->GetPostStepPoint();
 
     fpState = (G4ITStepProcessorState*) fpITrack->GetTrackingInfo()->GetStepProcessorState();
 
     GetProcessInfo();
     ResetSecondaries();
 }

void G4ITStepProcessor::Stepping	(	G4Track *	track,
		const double &	timeStep
	)

Definition at line 94 of file G4ITStepProcessor2.cc.

References CleanProcessor(), DoStepping(), and SetTrack().

 {
     CleanProcessor();
     if(track == 0) return ; // maybe put an exception here
     fTimeStep = timeStep ;
     SetTrack(track);
     DoStepping();
 }

void G4ITStepProcessor::UpdateTrack ( G4Track * )

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

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation