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)
Data Structures
class	G4ITStepProcessorState
struct	ProcessGeneralInfo

---

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 CleanProcessor(), DBL_MAX, and ResetSecondaries().

{
    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 183 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 199 of file G4ITStepProcessor.cc.

References CleanProcessor(), DBL_MAX, fStoreTrajectory, kCarTolerance, ResetSecondaries(), and verboseLevel.

{
    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

(

G4ProcessManager *

)

[protected]

Definition at line 259 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::ActiveOnlyITProcess

(

)

[protected]

Definition at line 226 of file G4ITStepProcessor.cc.

References FatalException, G4cerr, G4cout, G4endl, G4Exception(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetProcessManager(), G4ParticleTableIterator< K, V >::reset(), 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::ApplyProductionCut

(

G4Track *

)

[protected]

Definition at line 570 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

(

)

[inline, protected]

Definition at line 314 of file G4ITStepProcessor.hh.

References G4StepPoint::GetPosition().

Referenced by ApplyProductionCut(), and InvokePSDIP().

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

void G4ITStepProcessor::CalculateStep

(

)

[protected]

void G4ITStepProcessor::CalculateStep

(

G4Track *

)

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

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 140 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 &

)

[protected]

Definition at line 50 of file G4ITStepProcessor2.cc.

References ApplyProductionCut(), DBL_MIN, fStopButAlive, G4ParticleDefinition::GetApplyCutsFlag(), 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 *

)

Definition at line 508 of file G4ITStepProcessor.cc.

References DoDefinePhysicalStepLength(), and SetTrack().

{
    SetTrack(track);
    DoDefinePhysicalStepLength();
}

void G4ITStepProcessor::DoCalculateStep

(

)

[protected]

void G4ITStepProcessor::DoDefinePhysicalStepLength

(

)

[protected]

Definition at line 698 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 108 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(), G4ITNavigator::ResetHierarchyAndLocate(), G4TrackingInformation::SetNavigatorState(), G4ITNavigator::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 464 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 158 of file G4ITStepProcessor.cc.

References ClearProcessInfo(), and Initialize().

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

void G4ITStepProcessor::GetAtRestIL

(

)

[protected]

Definition at line 453 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 408 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.

{return fpSecondary;}

const G4Step* G4ITStepProcessor::GetStep

(

)

const [inline]

Definition at line 94 of file G4ITStepProcessor.hh.

{return fpStep;}

G4Step* G4ITStepProcessor::GetStep

(

)

[inline]

Definition at line 93 of file G4ITStepProcessor.hh.

Referenced by SetTrack().

{return fpStep;}

const G4Track * G4ITStepProcessor::GetTrack

(

)

const [inline]

Definition at line 309 of file G4ITStepProcessor.hh.

{
    return fpTrack;
}

G4Track* G4ITStepProcessor::GetTrack

(

)

[inline]

Definition at line 92 of file G4ITStepProcessor.hh.

{return fpTrack;}

G4ITTrackingManager* G4ITStepProcessor::GetTrackingManager

(

)

[inline]

Definition at line 99 of file G4ITStepProcessor.hh.

{return fpTrackingManager;}

void G4ITStepProcessor::InitDefineStep

(

)

[protected]

Definition at line 611 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(), 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 167 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 325 of file G4ITStepProcessor2.cc.

References G4VProcess::AlongStepDoIt(), G4VParticleChange::Clear(), DBL_MIN, DealWithSecondaries(), fAlive, fExclusivelyForcedProc, fStopAndKill, fStopButAlive, G4Track::GetKineticEnergy(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4Track::GetTrackStatus(), G4VParticleChange::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 275 of file G4ITStepProcessor2.cc.

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

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 383 of file G4ITStepProcessor2.cc.

References ExclusivelyForced, fExclusivelyForcedProc, Forced, fPostStepDoItProc, 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

)

[protected]

Definition at line 430 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 518 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 218 of file G4ITStepProcessor.cc.

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

void G4ITStepProcessor::ResetSecondaries

(

)

[protected]

Definition at line 444 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 516 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(), 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

)

[inline, protected]

Definition at line 321 of file G4ITStepProcessor.hh.

Referenced by Initialize().

{
    fpNavigator = value;
}

void G4ITStepProcessor::SetPreviousStepTime

(

G4double

)

[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.

{fpStep = val;}

void G4ITStepProcessor::SetTrack

(

G4Track *

)

[protected]

Definition at line 378 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.

{fpTrackingManager = trackMan;}

void G4ITStepProcessor::SetupGeneralProcessInfo	(	G4ParticleDefinition *	,
		G4ProcessManager *
	)			[protected]

Definition at line 277 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 431 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 *	,
		const double &
	)

Definition at line 95 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:

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

---