G4ITStepProcessor Class Reference

#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() [1/2]

G4ITStepProcessor::G4ITStepProcessor

(

)

Definition at line 63 of file G4ITStepProcessor.cc.

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

~G4ITStepProcessor()

G4ITStepProcessor::~G4ITStepProcessor ( )

virtual

Definition at line 183 of file G4ITStepProcessor.cc.

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

G4ITStepProcessor() [2/2]

G4ITStepProcessor::G4ITStepProcessor ( const G4ITStepProcessor &  other )

protected

Definition at line 199 of file G4ITStepProcessor.cc.

{
    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

ActiveOnlyITProcess() [1/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( )

protected

Definition at line 226 of file G4ITStepProcessor.cc.

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

Referenced by ActiveOnlyITProcess().

ActiveOnlyITProcess() [2/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( G4ProcessManager *  processManager )

protected

Definition at line 259 of file G4ITStepProcessor.cc.

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

ApplyProductionCut()

void G4ITStepProcessor::ApplyProductionCut ( G4Track *  aSecondary )

protected

Definition at line 570 of file G4ITStepProcessor2.cc.

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

Referenced by DealWithSecondaries().

CalculateSafety()

G4double G4ITStepProcessor::CalculateSafety ( )

inlineprotected

Definition at line 314 of file G4ITStepProcessor.hh.

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

Referenced by ApplyProductionCut(), and InvokePSDIP().

CalculateStep() [1/3]

void G4ITStepProcessor::CalculateStep ( )

protected

CalculateStep() [2/3]

void G4ITStepProcessor::CalculateStep

(

G4Track *

)

CalculateStep() [3/3]

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

CleanProcessor()

void G4ITStepProcessor::CleanProcessor ( )

inline

Definition at line 326 of file G4ITStepProcessor.hh.

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

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

ClearProcessInfo()

void G4ITStepProcessor::ClearProcessInfo ( )

protected

Definition at line 140 of file G4ITStepProcessor.cc.

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

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

CloneProcesses()

void G4ITStepProcessor::CloneProcesses ( )

protected

DealWithSecondaries()

void G4ITStepProcessor::DealWithSecondaries ( G4int &  counter )

protected

Definition at line 50 of file G4ITStepProcessor2.cc.

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

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

DefinePhysicalStepLength()

void G4ITStepProcessor::DefinePhysicalStepLength

(

G4Track *

track

)

Definition at line 508 of file G4ITStepProcessor.cc.

{
    SetTrack(track);
    DoDefinePhysicalStepLength();
}

DoCalculateStep()

void G4ITStepProcessor::DoCalculateStep ( )

protected

DoDefinePhysicalStepLength()

void G4ITStepProcessor::DoDefinePhysicalStepLength ( )

protected

Definition at line 698 of file G4ITStepProcessor.cc.

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

Referenced by DefinePhysicalStepLength().

DoIt()

void G4ITStepProcessor::DoIt	(	G4Track *	,
		double
	)

DoStepping()

void G4ITStepProcessor::DoStepping ( )

protected

Definition at line 108 of file G4ITStepProcessor2.cc.

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

Referenced by Stepping().

FindTransportationStep()

void G4ITStepProcessor::FindTransportationStep

(

)

Definition at line 464 of file G4ITStepProcessor2.cc.

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

Referenced by DoStepping().

ForceReInitialization()

void G4ITStepProcessor::ForceReInitialization

(

)

Definition at line 158 of file G4ITStepProcessor.cc.

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

GetAtRestIL()

void G4ITStepProcessor::GetAtRestIL ( )

protected

Definition at line 453 of file G4ITStepProcessor.cc.

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

Referenced by DoDefinePhysicalStepLength().

GetInteractionTime()

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 359 of file G4ITStepProcessor.hh.

{
    return fTimeStep ;
}

GetProcessInfo()

void G4ITStepProcessor::GetProcessInfo ( )

protected

Definition at line 408 of file G4ITStepProcessor.cc.

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

Referenced by SetupMembers().

GetSecondaries()

G4TrackVector * G4ITStepProcessor::GetSecondaries ( )

inline

Definition at line 97 of file G4ITStepProcessor.hh.

{return fpSecondary;}

GetStep() [1/2]

G4Step * G4ITStepProcessor::GetStep ( )

inline

Definition at line 93 of file G4ITStepProcessor.hh.

{return fpStep;}

Referenced by SetTrack().

GetStep() [2/2]

const G4Step * G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 94 of file G4ITStepProcessor.hh.

{return fpStep;}

GetTrack() [1/2]

G4Track * G4ITStepProcessor::GetTrack ( )

inline

Definition at line 92 of file G4ITStepProcessor.hh.

{return fpTrack;}

GetTrack() [2/2]

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 309 of file G4ITStepProcessor.hh.

{
    return fpTrack;
}

GetTrackingManager()

G4ITTrackingManager * G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 99 of file G4ITStepProcessor.hh.

{return fpTrackingManager;}

InitDefineStep()

void G4ITStepProcessor::InitDefineStep ( )

protected

Definition at line 611 of file G4ITStepProcessor.cc.

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

Referenced by DoDefinePhysicalStepLength().

Initialize()

void G4ITStepProcessor::Initialize ( )

virtual

Definition at line 167 of file G4ITStepProcessor.cc.

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

Referenced by ForceReInitialization().

InvokeAlongStepDoItProcs()

void G4ITStepProcessor::InvokeAlongStepDoItProcs ( )

protected

Definition at line 325 of file G4ITStepProcessor2.cc.

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

Referenced by DoStepping().

InvokeAtRestDoItProcs()

void G4ITStepProcessor::InvokeAtRestDoItProcs ( )

protected

Definition at line 275 of file G4ITStepProcessor2.cc.

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

Referenced by DoStepping().

InvokePostStepDoItProcs()

void G4ITStepProcessor::InvokePostStepDoItProcs ( )

protected

Definition at line 383 of file G4ITStepProcessor2.cc.

{
 
    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++){
}

Referenced by DoStepping().

InvokePSDIP()

void G4ITStepProcessor::InvokePSDIP ( size_t  np )

protected

Definition at line 430 of file G4ITStepProcessor2.cc.

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

Referenced by InvokePostStepDoItProcs(), and InvokeTransportationProc().

InvokeTransportationProc()

void G4ITStepProcessor::InvokeTransportationProc ( )

protected

Definition at line 518 of file G4ITStepProcessor2.cc.

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

Referenced by DoStepping().

operator=()

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

protected

Definition at line 218 of file G4ITStepProcessor.cc.

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

ResetSecondaries()

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 444 of file G4ITStepProcessor.cc.

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

Referenced by G4ITStepProcessor(), and SetupMembers().

SetInitialStep()

void G4ITStepProcessor::SetInitialStep ( )

protected

Definition at line 516 of file G4ITStepProcessor.cc.

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

Referenced by InitDefineStep().

SetNavigator()

void G4ITStepProcessor::SetNavigator ( G4ITNavigator *  value )

inlineprotected

Definition at line 321 of file G4ITStepProcessor.hh.

{
    fpNavigator = value;
}

Referenced by Initialize().

SetPreviousStepTime()

void G4ITStepProcessor::SetPreviousStepTime ( G4double  previousTimeStep )

inline

Definition at line 304 of file G4ITStepProcessor.hh.

{
    fPreviousTimeStep = previousTimeStep;
}

SetStep()

void G4ITStepProcessor::SetStep ( G4Step *  val )

inline

Definition at line 95 of file G4ITStepProcessor.hh.

{fpStep = val;}

SetTrack()

void G4ITStepProcessor::SetTrack ( G4Track *  track )

protected

Definition at line 378 of file G4ITStepProcessor.cc.

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

Referenced by DefinePhysicalStepLength(), and Stepping().

SetTrackingManager()

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager *  trackMan )

inline

Definition at line 98 of file G4ITStepProcessor.hh.

{fpTrackingManager = trackMan;}

SetupGeneralProcessInfo()

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

protected

Definition at line 277 of file G4ITStepProcessor.cc.

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

Referenced by GetProcessInfo().

SetupMembers()

void G4ITStepProcessor::SetupMembers ( )

protected

Definition at line 431 of file G4ITStepProcessor.cc.

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

Referenced by DoStepping(), and InitDefineStep().

Stepping()

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

Definition at line 95 of file G4ITStepProcessor2.cc.

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

UpdateTrack()

void G4ITStepProcessor::UpdateTrack

(

G4Track *

)

---

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

• G4ITStepProcessor.hh
• G4ITStepProcessor.cc
• G4ITStepProcessor2.cc