G4ITStepProcessor Class Reference

#include <G4ITStepProcessor.hh>

Public Member Functions
void	CleanProcessor ()
G4double	ComputeInteractionLength (double previousTimeStep)
void	DefinePhysicalStepLength (G4Track *)
void	DoIt (double timeStep)
void	ExtractDoItData ()
void	FindTransportationStep ()
void	ForceReInitialization ()
	G4ITStepProcessor ()
size_t	GetAtRestDoItProcTriggered () const
G4ForceCondition	GetCondition () const
const G4VITProcess *	GetCurrentProcess () const
const ProcessGeneralInfo *	GetCurrentProcessInfo () const
const G4VPhysicalVolume *	GetCurrentVolume () const
G4GPILSelection	GetGPILSelection () const
G4double	GetILTimeStep ()
double	GetInteractionTime ()
G4int	GetN2ndariesAlongStepDoIt () const
G4int	GetN2ndariesAtRestDoIt () const
G4int	GetN2ndariesPostStepDoIt () const
const G4VParticleChange *	GetParticleChange () const
G4double	GetPhysIntLength () const
size_t	GetPostStepAtTimeDoItProcTriggered () const
size_t	GetPostStepDoItProcTriggered () const
const G4ITStepProcessorState *	GetProcessorState () const
G4TrackVector *	GetSecondaries () const
G4Step *	GetStep ()
const G4Step *	GetStep () const
G4Track *	GetTrack ()
const G4Track *	GetTrack () const
G4ITTrackingManager *	GetTrackingManager ()
virtual void	Initialize ()
void	PrepareLeadingTracks ()
void	ResetLeadingTracks ()
void	SetPreviousStepTime (G4double)
void	SetStep (G4Step *val)
void	SetTrackingManager (G4ITTrackingManager *trackMan)
void	Stepping (G4Track *, const double &)
virtual	~G4ITStepProcessor ()

Protected Member Functions
void	ActiveOnlyITProcess ()
void	ActiveOnlyITProcess (G4ProcessManager *)
void	ApplyProductionCut (G4Track *)
G4double	CalculateSafety ()
void	ClearProcessInfo ()
void	DealWithSecondaries (G4int &)
void	DoDefinePhysicalStepLength ()
void	DoStepping ()
void	ExtractILData ()
	G4ITStepProcessor (const G4ITStepProcessor &other)
void	GetAtRestIL ()
void	GetProcessInfo ()
void	InitDefineStep ()
void	InvokeAlongStepDoItProcs ()
void	InvokeAtRestDoItProcs ()
void	InvokePostStepDoItProcs ()
void	InvokePSDIP (size_t)
void	InvokeTransportationProc ()
G4ITStepProcessor &	operator= (const G4ITStepProcessor &other)
void	PushSecondaries ()
void	ResetSecondaries ()
void	SetInitialStep ()
void	SetNavigator (G4ITNavigator *value)
void	SetTrack (G4Track *)
void	SetupGeneralProcessInfo (G4ParticleDefinition *, G4ProcessManager *)
void	SetupMembers ()

Private Attributes
size_t	fAtRestDoItProcTriggered
G4ForceCondition	fCondition
G4GPILSelection	fGPILSelection
G4double	fILTimeStep
G4bool	fInitialized
G4ITLeadingTracks	fLeadingTracks
G4int	fN2ndariesAlongStepDoIt
G4int	fN2ndariesAtRestDoIt
G4int	fN2ndariesPostStepDoIt
G4VITProcess *	fpCurrentProcess
G4VPhysicalVolume *	fpCurrentVolume
G4double	fPhysIntLength
G4IT *	fpITrack
G4ITNavigator *	fpNavigator
size_t	fPostStepAtTimeDoItProcTriggered
size_t	fPostStepDoItProcTriggered
G4VParticleChange *	fpParticleChange
G4StepPoint *	fpPostStepPoint
G4StepPoint *	fpPreStepPoint
ProcessGeneralInfo *	fpProcessInfo
G4double	fPreviousTimeStep
std::map< const G4ParticleDefinition *, ProcessGeneralInfo * >	fProcessGeneralInfoMap
G4TrackVector *	fpSecondary
G4ITStepProcessorState *	fpState
G4Step *	fpStep
G4Track *	fpTrack
G4ITTrackHolder *	fpTrackContainer
G4TrackingInformation *	fpTrackingInfo
G4ITTrackingManager *	fpTrackingManager
G4ITTransportation *	fpTransportation
G4VITSteppingVerbose *	fpVerbose
G4int	fStoreTrajectory
G4double	fTimeStep
G4double	kCarTolerance

Friends
class	G4Scheduler

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 153 of file G4ITStepProcessor.hh.

Constructor & Destructor Documentation

G4ITStepProcessor() [1/2]

G4ITStepProcessor::G4ITStepProcessor

(

)

Definition at line 76 of file G4ITStepProcessor.cc.

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

References CleanProcessor(), DBL_MAX, fILTimeStep, fInitialized, fpNavigator, fPreviousTimeStep, fpTrackContainer, fpTrackingManager, fpVerbose, fStoreTrajectory, kCarTolerance, and ResetSecondaries().

~G4ITStepProcessor()

G4ITStepProcessor::~G4ITStepProcessor ( )

virtual

Definition at line 228 of file G4ITStepProcessor.cc.

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

References ClearProcessInfo(), G4Step::DeleteSecondaryVector(), fpSecondary, and fpStep.

G4ITStepProcessor() [2/2]

G4ITStepProcessor::G4ITStepProcessor ( const G4ITStepProcessor &  other )

protected

Definition at line 244 of file G4ITStepProcessor.cc.

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

References CleanProcessor(), DBL_MAX, fILTimeStep, fInitialized, fpNavigator, fPreviousTimeStep, fpTrackContainer, fpTrackingManager, fpVerbose, fStoreTrajectory, kCarTolerance, and ResetSecondaries().

Member Function Documentation

ActiveOnlyITProcess() [1/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( )

protected

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

References ActiveOnlyITProcess(), FatalException, G4cerr, G4cout, G4endl, G4Exception(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetProcessManager(), and theParticleIterator.

Referenced by ActiveOnlyITProcess().

ActiveOnlyITProcess() [2/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( G4ProcessManager *  processManager )

protected

Definition at line 323 of file G4ITStepProcessor.cc.

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

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

ApplyProductionCut()

void G4ITStepProcessor::ApplyProductionCut ( G4Track *  aSecondary )

protected

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

References G4Step::AddTotalEnergyDeposit(), CalculateSafety(), DBL_MIN, fpPreStepPoint, fpStep, 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().

CalculateSafety()

G4double G4ITStepProcessor::CalculateSafety ( )

inlineprotected

Definition at line 441 of file G4ITStepProcessor.hh.

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

References G4ITStepProcessorState::fEndpointSafety, G4ITStepProcessorState::fEndpointSafOrigin, fpPostStepPoint, fpState, G4StepPoint::GetPosition(), kCarTolerance, and G4INCL::Math::max().

Referenced by ApplyProductionCut(), and InvokePSDIP().

CleanProcessor()

void G4ITStepProcessor::CleanProcessor ( )

inline

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

References DBL_MAX, fAtRestDoItProcTriggered, fCondition, fGPILSelection, fpCurrentProcess, fpCurrentVolume, fPhysIntLength, fpITrack, fPostStepAtTimeDoItProcTriggered, fPostStepDoItProcTriggered, fpParticleChange, fpPostStepPoint, fpPreStepPoint, fpProcessInfo, fpSecondary, fpState, fpStep, fpTrack, fpTrackingInfo, fpTransportation, fTimeStep, INT_MAX, NotCandidateForSelection, and NotForced.

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

ClearProcessInfo()

void G4ITStepProcessor::ClearProcessInfo ( )

protected

Definition at line 170 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();
}

References fProcessGeneralInfoMap.

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

ComputeInteractionLength()

G4double G4ITStepProcessor::ComputeInteractionLength

(

double

previousTimeStep

)

Definition at line 603 of file G4ITStepProcessor.cc.

{
  G4TrackManyList* mainList = fpTrackContainer->GetMainList();
  G4TrackManyList::iterator it = mainList ->begin();
  G4TrackManyList::iterator end = mainList ->end();
 
  SetPreviousStepTime(previousTimeStep);
 
  fILTimeStep = DBL_MAX;
 
  for (; it != end; )
  {
    G4Track * track = *it;
 
#ifdef DEBUG
    G4cout << "*CIL* " << GetIT(track)->GetName()
        << " ID: " << track->GetTrackID()
        <<  " at time : " << track->GetGlobalTime()
        << G4endl;
#endif
 
    ++it;
    DefinePhysicalStepLength(track);
 
    ExtractILData();
  }
 
  return fILTimeStep;
}

References G4ManyFastLists< OBJECT >::begin(), DBL_MAX, DefinePhysicalStepLength(), G4ManyFastLists< OBJECT >::end(), ExtractILData(), fILTimeStep, fpTrackContainer, G4cout, G4endl, G4Track::GetGlobalTime(), GetIT(), G4ITTrackHolder::GetMainList(), G4IT::GetName(), G4Track::GetTrackID(), and SetPreviousStepTime().

Referenced by G4Scheduler::Stepping().

DealWithSecondaries()

void G4ITStepProcessor::DealWithSecondaries ( G4int &  counter )

protected

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

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

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

DefinePhysicalStepLength()

void G4ITStepProcessor::DefinePhysicalStepLength

(

G4Track *

track

)

Definition at line 698 of file G4ITStepProcessor.cc.

{
  SetTrack(track);
  DoDefinePhysicalStepLength();
}

References DoDefinePhysicalStepLength(), and SetTrack().

Referenced by ComputeInteractionLength().

DoDefinePhysicalStepLength()

void G4ITStepProcessor::DoDefinePhysicalStepLength ( )

protected

Definition at line 956 of file G4ITStepProcessor.cc.

{
 
  InitDefineStep();
 
#ifdef G4VERBOSE
  // !!!!! Verbose
  if(fpVerbose) fpVerbose->DPSLStarted();
#endif
 
  G4TrackStatus trackStatus = fpTrack->GetTrackStatus();
 
  if(trackStatus == fStopAndKill)
  {
    return;
  }
 
  if(trackStatus == fStopButAlive)
  {
    fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator
        ->GetNavigatorState());
    fpNavigator->ResetNavigatorState();
    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 = dynamic_cast<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);
 
#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->DPSLPostStep();
#endif
 
    fpCurrentProcess->ResetProcessState();
    //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->fProposedSafety = DBL_MAX;
  G4double safetyProposedToAndByProcess = fpState->fProposedSafety;
 
  for(size_t kp = 0; kp < fpProcessInfo->MAXofAlongStepLoops; kp++)
  {
    fpCurrentProcess = dynamic_cast<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);
 
#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->DPSLAlongStep();
#endif
 
    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();
      }
    }
 
    // Handle PostStep processes sending back time steps rather than space length
    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);
    fpCurrentProcess->ResetProcessState();
 
    // Make sure to check the safety, even if Step is not limited
    //  by this process.                      J. Apostolakis, June 20, 1998
    //
    if(safetyProposedToAndByProcess < fpState->fProposedSafety)
    // proposedSafety keeps the smallest value:
    fpState->fProposedSafety = safetyProposedToAndByProcess;
    else
    // safetyProposedToAndByProcess always proposes a valid safety:
    safetyProposedToAndByProcess = fpState->fProposedSafety;
 
  }
 
  fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
  fpNavigator->ResetNavigatorState();
}

References G4VProcess::AlongStepGPIL(), CandidateForSelection, G4ITTransportation::ComputeStep(), Conditionally, DBL_MAX, G4VITSteppingVerbose::DPSLAlongStep(), G4VITSteppingVerbose::DPSLPostStep(), G4VITSteppingVerbose::DPSLStarted(), ExclusivelyForced, fAlongStepDoItProc, FatalErrorInArgument, FatalException, fCondition, fExclusivelyForcedProc, fGeomBoundary, fGPILSelection, Forced, ProcessGeneralInfo::fpAlongStepGetPhysIntVector, fpCurrentProcess, G4ITStepProcessorState::fPhysicalStep, fPhysIntLength, fpITrack, fpNavigator, fPostStepAtTimeDoItProcTriggered, fPostStepDoItProc, fPostStepDoItProcTriggered, ProcessGeneralInfo::fpPostStepGetPhysIntVector, fpProcessInfo, G4ITStepProcessorState::fPreviousStepSize, G4ITStepProcessorState::fProposedSafety, fpState, fpStep, fpTrack, fpTrackingInfo, fpTransportation, fpVerbose, G4ITStepProcessorState::fSelectedPostStepDoItVector, G4ITStepProcessorState::fStepStatus, fStopAndKill, fStopButAlive, fTimeStep, fWorldBoundary, G4Exception(), GetAtRestIL(), G4VITProcess::GetInteractionTimeLeft(), G4Track::GetNextVolume(), G4Step::GetPostStepPoint(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4IT::GetTrackingInfo(), G4Track::GetTrackStatus(), InActivated, InitDefineStep(), ProcessGeneralInfo::MAXofAlongStepLoops, ProcessGeneralInfo::MAXofPostStepLoops, NotForced, G4VProcess::PostStepGPIL(), G4VITProcess::ProposesTimeStep(), G4VITProcess::ResetProcessState(), G4TrackingInformation::SetNavigatorState(), G4StepPoint::SetProcessDefinedStep(), G4VITProcess::SetProcessState(), and StronglyForced.

Referenced by DefinePhysicalStepLength().

DoIt()

void G4ITStepProcessor::DoIt

(

double

timeStep

)

Definition at line 111 of file G4ITStepProcessor2.cc.

{
  if(fpVerbose) fpVerbose->DoItStarted();
 
  G4TrackManyList* mainList = fpTrackContainer->GetMainList();
  G4TrackManyList::iterator it = mainList->end();
  it--;
  size_t initialSize = mainList->size();
 
//    G4cout << "initialSize = " << initialSize << G4endl;
 
  for(size_t i = 0 ; i < initialSize ; ++i)
  {
 
//      G4cout << "i = " << i << G4endl;
 
    G4Track* track = *it;
    if (!track)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "No track was pop back the main track list.";
      G4Exception("G4ITStepProcessor::DoIt", "NO_TRACK",
                  FatalException, exceptionDescription);
    }
    // G4TrackManyList::iterator next_it (it);
    // next_it--;
    // it = next_it;
 
    it--;
    // Must be called before EndTracking(track)
    // Otherwise the iterator will point to the list of killed tracks
 
    if(track->GetTrackStatus() == fStopAndKill)
    {
      fpTrackingManager->EndTracking(track);
//      G4cout << GetIT(track)->GetName() << G4endl;
//      G4cout << " ************************ CONTINUE ********************" << G4endl;
      continue;
    }
 
#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DOIT)
    MemStat mem_first, mem_second, mem_diff;
    mem_first = MemoryUsage();
#endif
 
    Stepping(track, timeStep);
 
#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DOIT)
    MemStat mem_intermediaire = MemoryUsage();
    mem_diff = mem_intermediaire-mem_first;
    G4cout << "\t\t >> || MEM || In DoIT with track "
        << track->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
    ExtractDoItData();
 
#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DOIT)
    mem_second = MemoryUsage();
    mem_diff = mem_second-mem_first;
    G4cout << "\t >> || MEM || In DoIT with track "
        << track->GetTrackID()
        << ", diff is : " << mem_diff << G4endl;
#endif
  }
 
 
  fpTrackContainer->MergeSecondariesWithMainList();
  fpTrackContainer->KillTracks(); // (18-06-15 : MK) Remove it ?
  fLeadingTracks.Reset();
}

References G4VITSteppingVerbose::DoItStarted(), G4ManyFastLists< OBJECT >::end(), G4ITTrackingManager::EndTracking(), ExtractDoItData(), FatalException, fLeadingTracks, fpTrackContainer, fpTrackingManager, fpVerbose, fStopAndKill, G4cout, G4endl, G4Exception(), G4ITTrackHolder::GetMainList(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4ITTrackHolder::KillTracks(), G4MemStat::MemoryUsage(), G4ITTrackHolder::MergeSecondariesWithMainList(), G4ITLeadingTracks::Reset(), G4ManyFastLists< OBJECT >::size(), and Stepping().

Referenced by G4Scheduler::Stepping().

DoStepping()

void G4ITStepProcessor::DoStepping ( )

protected

Definition at line 293 of file G4ITStepProcessor2.cc.

{
  SetupMembers();
 
#ifdef DEBUG_MEM
  MemStat mem_first, mem_second, mem_diff;
#endif
 
#ifdef DEBUG_MEM
  mem_first = MemoryUsage();
#endif
 
#ifdef G4VERBOSE
    if(fpVerbose) fpVerbose->PreStepVerbose(fpTrack);
#endif
 
  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)
  {/*
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "No process was found for particle :"
                         << fpTrack->GetDefinition()->GetParticleName();
    G4Exception("G4ITStepProcessor::DoStepping",
                "ITStepProcessorNoProcess",
                JustWarning,
                exceptionDescription);
 
    fpTrack->SetTrackStatus(fStopAndKill);
    fpState->fStepStatus = fUndefined;*/
    return;
  }
 
  //--------
  // Prelude
  //--------
#ifdef G4VERBOSE
  // !!!!! Verbose
  if(fpVerbose) fpVerbose->NewStep();
#endif
 
  //---------------------------------
  // AtRestStep, AlongStep and PostStep Processes
  //---------------------------------
 
  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
 
#ifdef DEBUG_MEM
  MemStat mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || G4ITStepProcessor::DoStepping || After dealing with navigator with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
  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);
 
#ifdef G4VERBOSE
            // !!!!! Verbose
      if(fpVerbose) fpVerbose->AtRestDoItInvoked();
#endif
 
    }
    // 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();
    }
 
#ifdef DEBUG_MEM
    mem_intermediaire = MemoryUsage();
    mem_diff = mem_intermediaire-mem_first;
    G4cout << "\t\t\t >> || MEM || G4ITStepProcessor::DoStepping || After FindTransportationStep() with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
    // 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();
 
#ifdef DEBUG_MEM
    mem_intermediaire = MemoryUsage();
    mem_diff = mem_intermediaire-mem_first;
    G4cout << "\t\t\t >> || MEM || G4ITStepProcessor::DoStepping || After InvokeAlongStepDoItProcs() with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->AlongStepDoItAllDone();
#endif
 
    // Update track by taking into account all changes by AlongStepDoIt
    // fpStep->UpdateTrack(); // done in InvokeAlongStepDoItProcs
 
    // Update safety after invocation of all AlongStepDoIts
    fpState->fEndpointSafOrigin = fpPostStepPoint->GetPosition();
 
    fpState->fEndpointSafety =
        std::max(fpState->fProposedSafety - GeomStepLength, kCarTolerance);
 
    fpStep->GetPostStepPoint()->SetSafety(fpState->fEndpointSafety);
 
    if(GetIT(fpTrack)->GetTrackingInfo()->IsLeadingStep())
    {
      // Invoke PostStepDoIt including G4ITTransportation::PSDI
      InvokePostStepDoItProcs();
 
#ifdef DEBUG_MEM
      mem_intermediaire = MemoryUsage();
      mem_diff = mem_intermediaire-mem_first;
      G4cout << "\t\t\t >> || MEM || G4ITStepProcessor::DoStepping || After InvokePostStepDoItProcs() with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->StepInfoForLeadingTrack();
#endif
    }
    else
    {
      // Only invoke transportation and all other forced processes
      InvokeTransportationProc();
      fpStep->GetPostStepPoint()->SetProcessDefinedStep(fpTransportation);
 
#ifdef DEBUG_MEM
      mem_intermediaire = MemoryUsage();
      mem_diff = mem_intermediaire-mem_first;
      G4cout << "\t\t\t >> || MEM || G4ITStepProcessor::DoStepping || After InvokeTransportationProc() with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
    }
 
#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->PostStepDoItAllDone();
#endif
  }
 
  fpNavigator->ResetNavigatorState();
 
#ifdef DEBUG_MEM
  mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || G4ITStepProcessor::DoStepping || After fpNavigator->SetNavigatorState with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
  //-------
  // Finale
  //-------
 
  // Update 'TrackLength' and remeber the Step length of the current Step
  fpTrack->AddTrackLength(fpStep->GetStepLength());
  fpTrack->IncrementCurrentStepNumber();
 
//#ifdef G4VERBOSE
// //    !!!!! Verbose
//  if(fpVerbose) fpVerbose->StepInfo();
//#endif
 
#ifdef G4VERBOSE
    if(fpVerbose) fpVerbose->PostStepVerbose(fpTrack);
#endif
 
//    G4cout << " G4ITStepProcessor::DoStepping  -- " <<fpTrack->GetTrackID() << " tps = " << fpTrack->GetGlobalTime() << G4endl;
 
  // 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.
 
#ifdef DEBUG_MEM
  MemStat mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || End of DoStepping() with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
  //    return fpState->fStepStatus;
}

References G4Track::AddTrackLength(), G4VITSteppingVerbose::AlongStepDoItAllDone(), G4ITTrackingManager::AppendStep(), G4VITSteppingVerbose::AtRestDoItInvoked(), FatalErrorInArgument, fAtRestDoItProc, G4ITStepProcessorState::fEndpointSafety, G4ITStepProcessorState::fEndpointSafOrigin, FindTransportationStep(), ProcessGeneralInfo::fpAtRestDoItVector, G4ITStepProcessorState::fPhysicalStep, fpITrack, fpNavigator, fPostStepDoItProc, fpPostStepPoint, fpProcessInfo, G4ITStepProcessorState::fProposedSafety, fpState, fpStep, fpTrack, fpTrackingManager, fpTransportation, fpVerbose, G4ITStepProcessorState::fStepStatus, fStopButAlive, G4cout, G4endl, G4Exception(), G4Track::GetDefinition(), GetIT(), G4TrackingInformation::GetNavigatorState(), G4ParticleDefinition::GetParticleName(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetStepLength(), G4Track::GetTrackID(), G4IT::GetTrackingInfo(), G4Track::GetTrackStatus(), G4Track::IncrementCurrentStepNumber(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePostStepDoItProcs(), InvokeTransportationProc(), G4TrackingInformation::IsLeadingStep(), kCarTolerance, G4INCL::Math::max(), ProcessGeneralInfo::MAXofAlongStepLoops, ProcessGeneralInfo::MAXofAtRestLoops, ProcessGeneralInfo::MAXofPostStepLoops, G4MemStat::MemoryUsage(), G4VITSteppingVerbose::NewStep(), G4VITSteppingVerbose::PostStepDoItAllDone(), G4VITSteppingVerbose::PostStepVerbose(), G4VITSteppingVerbose::PreStepVerbose(), G4StepPoint::SetProcessDefinedStep(), G4StepPoint::SetSafety(), G4Step::SetStepLength(), G4Track::SetStepLength(), G4StepPoint::SetStepStatus(), SetupMembers(), and G4VITSteppingVerbose::StepInfoForLeadingTrack().

Referenced by Stepping().

ExtractDoItData()

void G4ITStepProcessor::ExtractDoItData

(

)

Definition at line 192 of file G4ITStepProcessor2.cc.

{
  if (!fpTrack)
  {
    CleanProcessor();
    return;
  }
 
  G4TrackStatus status = fpTrack->GetTrackStatus();
 
  switch (status)
  {
    case fAlive:
    case fStopButAlive:
    case fSuspend:
    case fPostponeToNextEvent:
    default:
      PushSecondaries();
      break;
 
    case fStopAndKill:
      G4ITReactionSet::Instance()->RemoveReactionSet(fpTrack);
      PushSecondaries();
//      G4TrackList::Pop(fpTrack);
      fpTrackingManager->EndTracking(fpTrack);
//      fTrackContainer->PushToKill(fpTrack);
      break;
 
    case fKillTrackAndSecondaries:
      G4ITReactionSet::Instance()->RemoveReactionSet(fpTrack);
      if (fpSecondary)
      {
        for (size_t i = 0; i < fpSecondary->size(); ++i)
        {
          delete (*fpSecondary)[i];
        }
        fpSecondary->clear();
      }
//      G4TrackList::Pop(fpTrack);
      fpTrackingManager->EndTracking(fpTrack);
//      fTrackContainer->PushToKill(fpTrack);
      break;
  }
 
  CleanProcessor();
}

References CleanProcessor(), G4ITTrackingManager::EndTracking(), fAlive, fKillTrackAndSecondaries, fPostponeToNextEvent, fpSecondary, fpTrack, fpTrackingManager, fStopAndKill, fStopButAlive, fSuspend, G4Track::GetTrackStatus(), G4ITReactionSet::Instance(), PushSecondaries(), and G4ITReactionSet::RemoveReactionSet().

Referenced by DoIt().

ExtractILData()

void G4ITStepProcessor::ExtractILData ( )

protected

Definition at line 635 of file G4ITStepProcessor.cc.

{
  assert(fpTrack != 0);
  if (fpTrack == 0)
  {
    CleanProcessor();
    return;
  }
 
  // assert(fpTrack->GetTrackStatus() != fStopAndKill);
 
  if (fpTrack->GetTrackStatus() == fStopAndKill)
  {
//    trackContainer->GetMainList()->pop(fpTrack);
    fpTrackingManager->EndTracking(fpTrack);
    CleanProcessor();
    return;
  }
 
  if (IsInf(fTimeStep))
  {
    // G4cout << "!!!!!!!!!!!! IS INF " << track->GetTrackID() << G4endl;
    CleanProcessor();
    return;
  }
  else if (fTimeStep < fILTimeStep - DBL_EPSILON)
  {
    // G4cout << "!!!!!!!!!!!! TEMPS DIFFERENTS "
    //    << track->GetTrackID() << G4endl;
 
    fLeadingTracks.Reset();
 
    fILTimeStep = GetInteractionTime();
 
//    G4cout << "Will set leading step to true for time  :"
//           << SP -> GetInteractionTime() << " against fTimeStep : "
//           << G4BestUnit(fILTimeStep, "Time") << " the trackID is : " << track->GetTrackID()
//           << G4endl;
 
//    GetIT(fpTrack)->GetTrackingInfo()->SetLeadingStep(true);
    fLeadingTracks.Push(fpTrack);
  }
  else if(fabs(fILTimeStep - fTimeStep) < DBL_EPSILON )
  {
 
    // G4cout << "!!!!!!!!!!!! MEME TEMPS " << track->GetTrackID() << G4endl;
    // G4cout << "Will set leading step to true for time  :"
    //        << SP -> GetInteractionTime() << " against fTimeStep : "
    //        << fTimeStep << " the trackID is : " << track->GetTrackID()<< G4endl;
//    GetIT(fpTrack)->GetTrackingInfo()->SetLeadingStep(true);
    fLeadingTracks.Push(fpTrack);
  }
  // else
  // {
  //     G4cout << "!!!! Bigger time : " << "currentTime : "<<fILTimeStep
  //  << " proposedTime : " << SP -> GetInteractionTime() << G4endl;
  // }
 
  CleanProcessor();
}

References CleanProcessor(), DBL_EPSILON, G4ITTrackingManager::EndTracking(), fILTimeStep, fLeadingTracks, fpTrack, fpTrackingManager, fStopAndKill, fTimeStep, GetInteractionTime(), G4Track::GetTrackStatus(), IsInf(), G4ITLeadingTracks::Push(), and G4ITLeadingTracks::Reset().

Referenced by ComputeInteractionLength().

FindTransportationStep()

void G4ITStepProcessor::FindTransportationStep

(

)

Definition at line 802 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);
    fpTransportation->ResetProcessState();
  }
 
  if(physicalStep >= DBL_MAX)
  {
//    G4cout << "---- 2) Setting stop and kill for " << GetIT(fpTrack)->GetName() << G4endl;
    fpTrack -> SetTrackStatus(fStopAndKill);
    return;
  }
 
  fpState->fPhysicalStep = physicalStep;
}

References G4ITTransportation::ComputeStep(), DBL_MAX, FatalErrorInArgument, G4ITStepProcessorState::fPhysicalStep, fpITrack, fpProcessInfo, fpState, fpStep, fpTrack, fpTrackingInfo, ProcessGeneralInfo::fpTransportation, fpTransportation, fStopAndKill, fTimeStep, G4Exception(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4IT::GetTrack(), G4VITProcess::ResetProcessState(), and G4VITProcess::SetProcessState().

Referenced by DoStepping().

ForceReInitialization()

void G4ITStepProcessor::ForceReInitialization

(

)

Definition at line 189 of file G4ITStepProcessor.cc.

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

References ClearProcessInfo(), fInitialized, and Initialize().

GetAtRestDoItProcTriggered()

size_t G4ITStepProcessor::GetAtRestDoItProcTriggered ( ) const

inline

Definition at line 220 of file G4ITStepProcessor.hh.

  {
    return fAtRestDoItProcTriggered;
  }

References fAtRestDoItProcTriggered.

Referenced by G4VITSteppingVerbose::CopyState().

GetAtRestIL()

void G4ITStepProcessor::GetAtRestIL ( )

protected

Definition at line 540 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 = dynamic_cast<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->ResetProcessState();
 
    if(fCondition==Forced)
    {
      (fpState->fSelectedAtRestDoItVector)[ri] = Forced;
    }
    else
    {
      (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
      if(lifeTime < shortestLifeTime )
      {
        shortestLifeTime = lifeTime;
        fAtRestDoItProcTriggered = G4int(ri);
      }
    }
  }
 
  (fpState->fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
 
//  G4cout << " --> Selected at rest process : "
//         << (*fpProcessInfo->fpAtRestGetPhysIntVector)[fAtRestDoItProcTriggered]
//            ->GetProcessName()
//         << G4endl;
 
  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;
  }
}

References G4VProcess::AtRestGPIL(), DBL_MAX, fAtRestDoItProcTriggered, fCondition, Forced, ProcessGeneralInfo::fpAtRestGetPhysIntVector, fpCurrentProcess, fpProcessInfo, fpState, fpTrack, fpTrackingInfo, G4ITStepProcessorState::fSelectedAtRestDoItVector, fTimeStep, G4cerr, G4endl, G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), InActivated, ProcessGeneralInfo::MAXofAtRestLoops, NotForced, G4VITProcess::ResetProcessState(), and G4VITProcess::SetProcessState().

Referenced by DoDefinePhysicalStepLength().

GetCondition()

G4ForceCondition G4ITStepProcessor::GetCondition ( ) const

inline

Definition at line 285 of file G4ITStepProcessor.hh.

  {
    return fCondition;
  }

References fCondition.

Referenced by G4VITSteppingVerbose::CopyState().

GetCurrentProcess()

const G4VITProcess * G4ITStepProcessor::GetCurrentProcess ( ) const

inline

Definition at line 245 of file G4ITStepProcessor.hh.

  {
    return fpCurrentProcess;
  }

References fpCurrentProcess.

Referenced by G4VITSteppingVerbose::CopyState().

GetCurrentProcessInfo()

const ProcessGeneralInfo * G4ITStepProcessor::GetCurrentProcessInfo ( ) const

inline

Definition at line 265 of file G4ITStepProcessor.hh.

  {
    return fpProcessInfo;
  }

References fpProcessInfo.

Referenced by G4VITSteppingVerbose::CopyState().

GetCurrentVolume()

const G4VPhysicalVolume * G4ITStepProcessor::GetCurrentVolume ( ) const

inline

Definition at line 280 of file G4ITStepProcessor.hh.

  {
    return fpCurrentVolume;
  }

References fpCurrentVolume.

Referenced by G4VITSteppingVerbose::CopyState().

GetGPILSelection()

G4GPILSelection G4ITStepProcessor::GetGPILSelection ( ) const

inline

Definition at line 225 of file G4ITStepProcessor.hh.

  {
    return fGPILSelection;
  }

References fGPILSelection.

Referenced by G4VITSteppingVerbose::CopyState().

GetILTimeStep()

G4double G4ITStepProcessor::GetILTimeStep ( )

inline

Definition at line 203 of file G4ITStepProcessor.hh.

  {
    return fILTimeStep;
  }

References fILTimeStep.

GetInteractionTime()

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 491 of file G4ITStepProcessor.hh.

{
  return fTimeStep;
}

References fTimeStep.

Referenced by ExtractILData().

GetN2ndariesAlongStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesAlongStepDoIt ( ) const

inline

Definition at line 230 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAlongStepDoIt;
  }

References fN2ndariesAlongStepDoIt.

Referenced by G4VITSteppingVerbose::CopyState().

GetN2ndariesAtRestDoIt()

G4int G4ITStepProcessor::GetN2ndariesAtRestDoIt ( ) const

inline

Definition at line 235 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAtRestDoIt;
  }

References fN2ndariesAtRestDoIt.

Referenced by G4VITSteppingVerbose::CopyState().

GetN2ndariesPostStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesPostStepDoIt ( ) const

inline

Definition at line 240 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesPostStepDoIt;
  }

References fN2ndariesPostStepDoIt.

Referenced by G4VITSteppingVerbose::CopyState().

GetParticleChange()

const G4VParticleChange * G4ITStepProcessor::GetParticleChange ( ) const

inline

Definition at line 275 of file G4ITStepProcessor.hh.

  {
    return fpParticleChange;
  }

References fpParticleChange.

Referenced by G4VITSteppingVerbose::CopyState().

GetPhysIntLength()

G4double G4ITStepProcessor::GetPhysIntLength ( ) const

inline

Definition at line 250 of file G4ITStepProcessor.hh.

  {
    return fPhysIntLength;
  }

References fPhysIntLength.

Referenced by G4VITSteppingVerbose::CopyState().

GetPostStepAtTimeDoItProcTriggered()

size_t G4ITStepProcessor::GetPostStepAtTimeDoItProcTriggered ( ) const

inline

Definition at line 255 of file G4ITStepProcessor.hh.

  {
    return fPostStepAtTimeDoItProcTriggered;
  }

References fPostStepAtTimeDoItProcTriggered.

GetPostStepDoItProcTriggered()

size_t G4ITStepProcessor::GetPostStepDoItProcTriggered ( ) const

inline

Definition at line 260 of file G4ITStepProcessor.hh.

  {
    return fPostStepDoItProcTriggered;
  }

References fPostStepDoItProcTriggered.

Referenced by G4VITSteppingVerbose::CopyState().

GetProcessInfo()

void G4ITStepProcessor::GetProcessInfo ( )

protected

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

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

Referenced by SetupMembers().

GetProcessorState()

const G4ITStepProcessorState * G4ITStepProcessor::GetProcessorState ( ) const

inline

Definition at line 270 of file G4ITStepProcessor.hh.

  {
    return fpState;
  }

References fpState.

Referenced by G4VITSteppingVerbose::CopyState().

GetSecondaries()

G4TrackVector * G4ITStepProcessor::GetSecondaries ( ) const

inline

Definition at line 179 of file G4ITStepProcessor.hh.

  {
    return fpSecondary;
  }

References fpSecondary.

Referenced by G4VITSteppingVerbose::CopyState().

GetStep() [1/2]

G4Step * G4ITStepProcessor::GetStep ( )

inline

Definition at line 166 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

References fpStep.

Referenced by G4VITSteppingVerbose::CopyState().

GetStep() [2/2]

const G4Step * G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 170 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

References fpStep.

GetTrack() [1/2]

G4Track * G4ITStepProcessor::GetTrack ( )

inline

Definition at line 162 of file G4ITStepProcessor.hh.

  {
    return fpTrack;
  }

References fpTrack.

Referenced by G4VITSteppingVerbose::CopyState().

GetTrack() [2/2]

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 434 of file G4ITStepProcessor.hh.

{
  return fpTrack;
}

References fpTrack.

GetTrackingManager()

G4ITTrackingManager * G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 187 of file G4ITStepProcessor.hh.

  {
    return fpTrackingManager;
  }

References fpTrackingManager.

InitDefineStep()

void G4ITStepProcessor::InitDefineStep ( )

protected

ADDED BACK

ADDED BACK

Definition at line 850 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();
    SetInitialStep();
 
    fpTrackingManager->StartTracking(fpTrack);
  }
  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()()));
 
     //  G4VPhysicalVolume* newTopVolume=
     //     fpNavigator->LocateGlobalPointAndSetup(fpTrack->GetPosition(),
     //                                            &fpTrack->GetMomentumDirection(),
     //                                            true, false);
 
     //        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);
     }
 
     */
    //==========================================================================
    // Only reset navigator state + reset volume hierarchy (internal)
    // No need to relocate
    //==========================================================================
    fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()
        ->GetNavigatorState());
  }
}

References G4Step::CopyPostToPreStepPoint(), fpCurrentVolume, fpITrack, fpNavigator, G4ITStepProcessorState::fPreviousStepSize, fpSecondary, fpState, fpStep, fpTrack, fpTrackingManager, G4ITStepProcessorState::fTouchableHandle, G4TrackingInformation::GetNavigatorState(), G4Track::GetNextTouchableHandle(), G4StepPoint::GetPhysicalVolume(), G4Step::GetPreStepPoint(), G4Track::GetStepLength(), G4Track::GetTouchableHandle(), G4IT::GetTrackingInfo(), G4Step::NewSecondaryVector(), G4Step::ResetTotalEnergyDeposit(), SetInitialStep(), G4Track::SetNextTouchableHandle(), G4Step::SetPointerToVectorOfAuxiliaryPoints(), G4Track::SetStep(), G4TrackingInformation::SetStepProcessorState(), G4Track::SetTouchableHandle(), SetupMembers(), and G4ITTrackingManager::StartTracking().

Referenced by DoDefinePhysicalStepLength().

Initialize()

void G4ITStepProcessor::Initialize ( )

virtual

Definition at line 198 of file G4ITStepProcessor.cc.

{
  CleanProcessor();
  if(fInitialized) return;
  //    ActiveOnlyITProcess();
 
  SetNavigator(G4ITTransportationManager::GetTransportationManager()
      ->GetNavigatorForTracking());
 
  fPhysIntLength = DBL_MAX;
  kCarTolerance = 0.5
      * G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  if(fpVerbose == 0)
  {
    G4ITTrackingInteractivity* interactivity = fpTrackingManager->GetInteractivity();
 
    if(interactivity)
    {
      fpVerbose = interactivity->GetSteppingVerbose();
      fpVerbose->SetStepProcessor(this);
    }
  }
 
  fpTrackContainer = G4ITTrackHolder::Instance();
 
  fInitialized = true;
}

References CleanProcessor(), DBL_MAX, fInitialized, fPhysIntLength, fpTrackContainer, fpTrackingManager, fpVerbose, G4GeometryTolerance::GetInstance(), G4ITTrackingManager::GetInteractivity(), G4ITTrackingInteractivity::GetSteppingVerbose(), G4GeometryTolerance::GetSurfaceTolerance(), G4ITTransportationManager::GetTransportationManager(), G4ITTrackHolder::Instance(), kCarTolerance, SetNavigator(), and G4VITSteppingVerbose::SetStepProcessor().

Referenced by ForceReInitialization(), and G4Scheduler::Process().

InvokeAlongStepDoItProcs()

void G4ITStepProcessor::InvokeAlongStepDoItProcs ( )

protected

Definition at line 628 of file G4ITStepProcessor2.cc.

{
 
#ifdef DEBUG_MEM
  MemStat mem_first, mem_second, mem_diff;
#endif
 
#ifdef DEBUG_MEM
  mem_first = MemoryUsage();
#endif
 
  // 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);
 
#ifdef DEBUG_MEM
    MemStat mem_intermediaire = MemoryUsage();
    mem_diff = mem_intermediaire-mem_first;
    G4cout << "\t\t\t >> || MEM || After calling AlongStepDoIt for " << fpCurrentProcess->GetProcessName() << " and track "<< fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
//        fpCurrentProcess->SetProcessState(0);
    fpCurrentProcess->ResetProcessState();
    // Update the PostStepPoint of Step according to ParticleChange
 
    fpParticleChange->UpdateStepForAlongStep(fpStep);
 
#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->AlongStepDoItOneByOne();
#endif
 
    // 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();
  }
 
#ifdef DEBUG_MEM
  MemStat mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || After looping on processes with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
  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 );
  }
 
}

References G4VProcess::AlongStepDoIt(), G4VITSteppingVerbose::AlongStepDoItOneByOne(), G4VParticleChange::Clear(), DBL_MIN, DealWithSecondaries(), fAlive, fExclusivelyForcedProc, fN2ndariesAlongStepDoIt, ProcessGeneralInfo::fpAlongStepDoItVector, fpCurrentProcess, fpParticleChange, fpProcessInfo, fpState, fpStep, fpTrack, fpTrackingInfo, fpVerbose, G4ITStepProcessorState::fStepStatus, fStopAndKill, fStopButAlive, G4cout, G4endl, G4Track::GetKineticEnergy(), G4VITProcess::GetProcessID(), G4VProcess::GetProcessName(), G4TrackingInformation::GetProcessState(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4VParticleChange::GetTrackStatus(), ProcessGeneralInfo::MAXofAlongStepLoops, ProcessGeneralInfo::MAXofAtRestLoops, G4MemStat::MemoryUsage(), G4VITProcess::ResetProcessState(), G4VITProcess::SetProcessState(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForAlongStep(), and G4Step::UpdateTrack().

Referenced by DoStepping().

InvokeAtRestDoItProcs()

void G4ITStepProcessor::InvokeAtRestDoItProcs ( )

protected

Definition at line 561 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];
 
//      G4cout << " Invoke : "
//             << fpCurrentProcess->GetProcessName()
//             << G4endl;
 
      //  if(fpVerbose)
      //  {
      //    fpVerbose->AtRestDoItOneByOne();
      //  }
 
      fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess
          ->GetProcessID()));
      fpParticleChange = fpCurrentProcess->AtRestDoIt(*fpTrack, *fpStep);
      fpCurrentProcess->ResetProcessState();
 
      // 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);
 
      // 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();
 
    } //if(fSelectedAtRestDoItVector[np] != InActivated){
  } //for(size_t np=0; np < MAXofAtRestLoops; np++){
  fpStep->UpdateTrack();
 
  // Modification par rapport au transport standard :
  // fStopAndKill doit etre propose par le modele
  // sinon d autres processus AtRest seront appeles
  // au pas suivant
  // fpTrack->SetTrackStatus(fStopAndKill);
}

References G4VProcess::AtRestDoIt(), G4VParticleChange::Clear(), DealWithSecondaries(), fN2ndariesAtRestDoIt, ProcessGeneralInfo::fpAtRestDoItVector, fpCurrentProcess, fpParticleChange, fpProcessInfo, fpState, fpStep, fpTrack, fpTrackingInfo, G4ITStepProcessorState::fSelectedAtRestDoItVector, G4Step::GetPostStepPoint(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4VParticleChange::GetTrackStatus(), InActivated, ProcessGeneralInfo::MAXofAtRestLoops, G4VITProcess::ResetProcessState(), G4StepPoint::SetProcessDefinedStep(), G4VITProcess::SetProcessState(), G4Step::SetStepLength(), G4Track::SetStepLength(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForAtRest(), and G4Step::UpdateTrack().

Referenced by DoStepping().

InvokePostStepDoItProcs()

void G4ITStepProcessor::InvokePostStepDoItProcs ( )

protected

Definition at line 712 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 == 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 < _MAXofPostStepLoops; np1++)
      {
        G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops
                                                 - np1 - 1];
        if(Cond2 == StronglyForced)
        {
          InvokePSDIP(np1);
        }
      }
      break;
    }
  } //for(size_t np=0; np < MAXofPostStepLoops; np++){
}

References ExclusivelyForced, fExclusivelyForcedProc, Forced, fPostStepDoItProc, fpProcessInfo, fpState, fpTrack, G4ITStepProcessorState::fSelectedPostStepDoItVector, G4ITStepProcessorState::fStepStatus, fStopAndKill, G4Track::GetTrackStatus(), InActivated, InvokePSDIP(), ProcessGeneralInfo::MAXofPostStepLoops, NotForced, and StronglyForced.

Referenced by DoStepping().

InvokePSDIP()

void G4ITStepProcessor::InvokePSDIP ( size_t  np )

protected

Definition at line 762 of file G4ITStepProcessor2.cc.

{
  fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepDoItVector)[np];
 
  fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess
      ->GetProcessID()));
  fpParticleChange = fpCurrentProcess->PostStepDoIt(*fpTrack, *fpStep);
//    fpCurrentProcess->SetProcessState(0);
  fpCurrentProcess->ResetProcessState();
 
  // Update PostStepPoint of Step according to ParticleChange
  fpParticleChange->UpdateStepForPostStep(fpStep);
 
#ifdef G4VERBOSE
  // !!!!! Verbose
  if(fpVerbose) fpVerbose->PostStepDoItOneByOne();
#endif
 
  // 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();
}

References CalculateSafety(), G4VParticleChange::Clear(), DealWithSecondaries(), fN2ndariesPostStepDoIt, fpCurrentProcess, fpParticleChange, ProcessGeneralInfo::fpPostStepDoItVector, fpProcessInfo, fpStep, fpTrack, fpTrackingInfo, fpVerbose, G4Step::GetPostStepPoint(), G4VITProcess::GetProcessID(), G4TrackingInformation::GetProcessState(), G4VParticleChange::GetTrackStatus(), G4VProcess::PostStepDoIt(), G4VITSteppingVerbose::PostStepDoItOneByOne(), G4VITProcess::ResetProcessState(), G4VITProcess::SetProcessState(), G4StepPoint::SetSafety(), G4Track::SetTrackStatus(), G4VParticleChange::UpdateStepForPostStep(), and G4Step::UpdateTrack().

Referenced by InvokePostStepDoItProcs(), and InvokeTransportationProc().

InvokeTransportationProc()

void G4ITStepProcessor::InvokeTransportationProc ( )

protected

Definition at line 863 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(Cond != InActivated)
 
    // 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;
    }
  }
}

References ExclusivelyForced, fExclusivelyForcedProc, Forced, fpProcessInfo, fpState, fpTrack, G4ITStepProcessorState::fSelectedPostStepDoItVector, G4ITStepProcessorState::fStepStatus, fStopAndKill, G4Track::GetTrackStatus(), InActivated, InvokePSDIP(), ProcessGeneralInfo::MAXofPostStepLoops, and StronglyForced.

Referenced by DoStepping().

operator=()

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

protected

Definition at line 280 of file G4ITStepProcessor.cc.

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

PrepareLeadingTracks()

void G4ITStepProcessor::PrepareLeadingTracks

(

)

Definition at line 273 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.PrepareLeadingTracks();
}

References fLeadingTracks, and G4ITLeadingTracks::PrepareLeadingTracks().

Referenced by G4Scheduler::Stepping().

PushSecondaries()

void G4ITStepProcessor::PushSecondaries ( )

protected

Definition at line 241 of file G4ITStepProcessor2.cc.

{
  if (!fpSecondary || fpSecondary->empty())
  {
    // DEBUG
    //      G4cout << "NO SECONDARIES !!! " << G4endl;
    return;
  }
 
  // DEBUG
  //    G4cout << "There are secondaries : "<< secondaries -> size() << G4endl ;
 
  G4TrackVector::iterator secondaries_i = fpSecondary->begin();
 
  for (; secondaries_i != fpSecondary->end(); ++secondaries_i)
  {
    G4Track* secondary = *secondaries_i;
    fpTrackContainer->_PushTrack(secondary);
  }
}

References G4ITTrackHolder::_PushTrack(), fpSecondary, and fpTrackContainer.

Referenced by ExtractDoItData().

ResetLeadingTracks()

void G4ITStepProcessor::ResetLeadingTracks

(

)

Definition at line 266 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.Reset();
}

References fLeadingTracks, and G4ITLeadingTracks::Reset().

Referenced by G4Scheduler::Stepping().

ResetSecondaries()

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 530 of file G4ITStepProcessor.cc.

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

References fN2ndariesAlongStepDoIt, fN2ndariesAtRestDoIt, and fN2ndariesPostStepDoIt.

Referenced by G4ITStepProcessor(), and SetupMembers().

SetInitialStep()

void G4ITStepProcessor::SetInitialStep ( )

protected

Definition at line 706 of file G4ITStepProcessor.cc.

{
  // DEBUG
  //    G4cout << "SetInitialStep for : " << fpITrack-> GetName() << G4endl;
  //________________________________________________________
  // Initialize geometry
 
  if(!fpTrack->GetTouchableHandle())
  {
    //==========================================================================
    // Create navigator state and Locate particle in geometry
    //==========================================================================
    /*
     fpNavigator->NewNavigatorStateAndLocate(fpTrack->GetPosition(),
     fpTrack->GetMomentumDirection());
 
     fpITrack->GetTrackingInfo()->
     SetNavigatorState(fpNavigator->GetNavigatorState());
     */
    fpNavigator->NewNavigatorState();
    fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator
        ->GetNavigatorState());
 
    G4ThreeVector direction = fpTrack->GetMomentumDirection();
    fpNavigator->LocateGlobalPointAndSetup(fpTrack->GetPosition(),
                                           &direction,
                                           false,
                                           false); // was false, false
 
    fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
 
    fpTrack->SetTouchableHandle(fpState->fTouchableHandle);
    fpTrack->SetNextTouchableHandle(fpState->fTouchableHandle);
  }
  else
  {
    fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
    fpTrack->SetNextTouchableHandle(fpState->fTouchableHandle);
 
    //==========================================================================
    // Create OR set navigator state
    //==========================================================================
 
    if(fpITrack->GetTrackingInfo()->GetNavigatorState())
    {
      fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()
          ->GetNavigatorState());
      fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator
          ->GetNavigatorState());
    }
    else
    {
      fpNavigator->NewNavigatorState(*((G4TouchableHistory*) fpState
          ->fTouchableHandle()));
      fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator
          ->GetNavigatorState());
    }
 
    G4VPhysicalVolume* oldTopVolume =
        fpTrack->GetTouchableHandle()->GetVolume();
 
    //==========================================================================
    // Locate particle in geometry
    //==========================================================================
 
//    G4VPhysicalVolume* newTopVolume =
//        fpNavigator->LocateGlobalPointAndSetup(
//            fpTrack->GetPosition(),
//            &fpTrack->GetMomentumDirection(),
//            true, false);
 
    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);
  }
 
  //HoangTRAN: it's better to check the status here
  if(fpTrack->GetTrackStatus() == fStopAndKill) return;
 
  // 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 );
  }
 
  fpState->fStepStatus = fUndefined;
}

References fAlive, FatalException, fpCurrentVolume, fpITrack, fpNavigator, fPostponeToNextEvent, fpState, fpStep, fpTrack, G4ITStepProcessorState::fStepStatus, fStopAndKill, fStopButAlive, fSuspend, G4ITStepProcessorState::fTouchableHandle, fUndefined, G4cerr, G4cout, G4endl, G4Exception(), G4Track::GetCurrentStepNumber(), G4Track::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4Track::GetMomentumDirection(), G4TrackingInformation::GetNavigatorState(), G4Track::GetParentID(), G4Track::GetPosition(), G4VPhysicalVolume::GetRegularStructureId(), G4Track::GetTouchableHandle(), G4IT::GetTrackingInfo(), G4Track::GetTrackStatus(), G4Track::GetVolume(), G4VTouchable::GetVolume(), G4Step::InitializeStep(), G4Track::SetLogicalVolumeAtVertex(), G4TrackingInformation::SetNavigatorState(), G4Track::SetNextTouchableHandle(), G4Track::SetTouchableHandle(), G4Track::SetTrackStatus(), G4Track::SetVertexKineticEnergy(), G4Track::SetVertexMomentumDirection(), and G4Track::SetVertexPosition().

Referenced by InitDefineStep().

SetNavigator()

void G4ITStepProcessor::SetNavigator ( G4ITNavigator *  value )

inlineprotected

Definition at line 450 of file G4ITStepProcessor.hh.

{
  fpNavigator = value;
}

References fpNavigator.

Referenced by Initialize().

SetPreviousStepTime()

void G4ITStepProcessor::SetPreviousStepTime ( G4double  previousTimeStep )

inline

Definition at line 427 of file G4ITStepProcessor.hh.

{
  fPreviousTimeStep = previousTimeStep;
}

References fPreviousTimeStep.

Referenced by ComputeInteractionLength().

SetStep()

void G4ITStepProcessor::SetStep ( G4Step *  val )

inline

Definition at line 174 of file G4ITStepProcessor.hh.

  {
    fpStep = val;
  }

References fpStep.

SetTrack()

void G4ITStepProcessor::SetTrack ( G4Track *  track )

protected

Definition at line 454 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 errMsg;
      errMsg << "No IT pointer was attached to the track you try to process.";
      G4Exception("G4ITStepProcessor::SetTrack",
                  "ITStepProcessor0007",
                  FatalErrorInArgument,
                  errMsg);
    }
  }
  else
  {
    fpITrack = 0;
    fpStep = 0;
  }
}

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

Referenced by DefinePhysicalStepLength(), and Stepping().

SetTrackingManager()

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager *  trackMan )

inline

Definition at line 183 of file G4ITStepProcessor.hh.

  {
    fpTrackingManager = trackMan;
  }

References fpTrackingManager.

Referenced by G4Scheduler::Initialize().

SetupGeneralProcessInfo()

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

protected

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

References G4ProcessVector::entries(), FatalErrorInArgument, FatalException, ProcessGeneralInfo::fpAlongStepDoItVector, ProcessGeneralInfo::fpAlongStepGetPhysIntVector, ProcessGeneralInfo::fpAtRestDoItVector, ProcessGeneralInfo::fpAtRestGetPhysIntVector, ProcessGeneralInfo::fpPostStepDoItVector, ProcessGeneralInfo::fpPostStepGetPhysIntVector, fpProcessInfo, fProcessGeneralInfoMap, ProcessGeneralInfo::fpTransportation, G4cerr, G4cout, G4endl, G4Exception(), G4ProcessManager::GetAlongStepProcessVector(), G4ProcessManager::GetAtRestProcessVector(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGEncoding(), G4ProcessManager::GetPostStepProcessVector(), ProcessGeneralInfo::MAXofAlongStepLoops, ProcessGeneralInfo::MAXofAtRestLoops, ProcessGeneralInfo::MAXofPostStepLoops, SizeOfSelectedDoItVector, typeDoIt, and typeGPIL.

Referenced by GetProcessInfo().

SetupMembers()

void G4ITStepProcessor::SetupMembers ( )

protected

Definition at line 515 of file G4ITStepProcessor.cc.

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

References fpITrack, fpPostStepPoint, fpPreStepPoint, fpSecondary, fpState, fpStep, G4Step::GetfSecondary(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), GetProcessInfo(), G4TrackingInformation::GetStepProcessorState(), G4IT::GetTrackingInfo(), and ResetSecondaries().

Referenced by DoStepping(), and InitDefineStep().

Stepping()

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

Definition at line 264 of file G4ITStepProcessor2.cc.

{
 
#ifdef DEBUG_MEM
  MemStat mem_first, mem_second, mem_diff;
#endif
 
#ifdef DEBUG_MEM
  mem_first = MemoryUsage();
#endif
 
  CleanProcessor();
 
#ifdef DEBUG_MEM
  MemStat mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || After CleanProcessor " << track->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif
 
  if(track == 0) return; // maybe put an exception here
  fTimeStep = timeStep;
  SetTrack(track);
  DoStepping();
}

References CleanProcessor(), DoStepping(), fTimeStep, G4cout, G4endl, G4Track::GetTrackID(), G4MemStat::MemoryUsage(), and SetTrack().

Referenced by DoIt().

Friends And Related Function Documentation

G4Scheduler

friend class G4Scheduler

friend

Definition at line 155 of file G4ITStepProcessor.hh.

Field Documentation

fAtRestDoItProcTriggered

size_t G4ITStepProcessor::fAtRestDoItProcTriggered

private

Definition at line 377 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), GetAtRestDoItProcTriggered(), and GetAtRestIL().

fCondition

G4ForceCondition G4ITStepProcessor::fCondition

private

Definition at line 382 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), GetAtRestIL(), and GetCondition().

fGPILSelection

G4GPILSelection G4ITStepProcessor::fGPILSelection

private

Definition at line 383 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), and GetGPILSelection().

fILTimeStep

G4double G4ITStepProcessor::fILTimeStep

private

Definition at line 359 of file G4ITStepProcessor.hh.

Referenced by ComputeInteractionLength(), ExtractILData(), G4ITStepProcessor(), and GetILTimeStep().

fInitialized

G4bool G4ITStepProcessor::fInitialized

private

Definition at line 339 of file G4ITStepProcessor.hh.

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

fLeadingTracks

G4ITLeadingTracks G4ITStepProcessor::fLeadingTracks

private

Definition at line 351 of file G4ITStepProcessor.hh.

Referenced by DoIt(), ExtractILData(), PrepareLeadingTracks(), and ResetLeadingTracks().

fN2ndariesAlongStepDoIt

G4int G4ITStepProcessor::fN2ndariesAlongStepDoIt

private

Definition at line 371 of file G4ITStepProcessor.hh.

Referenced by GetN2ndariesAlongStepDoIt(), InvokeAlongStepDoItProcs(), and ResetSecondaries().

fN2ndariesAtRestDoIt

G4int G4ITStepProcessor::fN2ndariesAtRestDoIt

private

Definition at line 370 of file G4ITStepProcessor.hh.

Referenced by DealWithSecondaries(), GetN2ndariesAtRestDoIt(), InvokeAtRestDoItProcs(), and ResetSecondaries().

fN2ndariesPostStepDoIt

G4int G4ITStepProcessor::fN2ndariesPostStepDoIt

private

Definition at line 372 of file G4ITStepProcessor.hh.

Referenced by GetN2ndariesPostStepDoIt(), InvokePSDIP(), and ResetSecondaries().

fpCurrentProcess

G4VITProcess* G4ITStepProcessor::fpCurrentProcess

private

Definition at line 365 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DealWithSecondaries(), DoDefinePhysicalStepLength(), GetAtRestIL(), GetCurrentProcess(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), and InvokePSDIP().

fpCurrentVolume

G4VPhysicalVolume* G4ITStepProcessor::fpCurrentVolume

private

Definition at line 396 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), GetCurrentVolume(), InitDefineStep(), and SetInitialStep().

fPhysIntLength

G4double G4ITStepProcessor::fPhysIntLength

private

Definition at line 389 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), GetPhysIntLength(), and Initialize().

fpITrack

G4IT* G4ITStepProcessor::fpITrack

private

Definition at line 415 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), DoStepping(), FindTransportationStep(), InitDefineStep(), SetInitialStep(), SetTrack(), and SetupMembers().

fpNavigator

G4ITNavigator* G4ITStepProcessor::fpNavigator

private

Definition at line 346 of file G4ITStepProcessor.hh.

Referenced by DoDefinePhysicalStepLength(), DoStepping(), G4ITStepProcessor(), InitDefineStep(), SetInitialStep(), and SetNavigator().

fPostStepAtTimeDoItProcTriggered

size_t G4ITStepProcessor::fPostStepAtTimeDoItProcTriggered

private

Definition at line 379 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), and GetPostStepAtTimeDoItProcTriggered().

fPostStepDoItProcTriggered

size_t G4ITStepProcessor::fPostStepDoItProcTriggered

private

Definition at line 378 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), and GetPostStepDoItProcTriggered().

fpParticleChange

G4VParticleChange* G4ITStepProcessor::fpParticleChange

private

Definition at line 363 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DealWithSecondaries(), GetParticleChange(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), and InvokePSDIP().

fpPostStepPoint

G4StepPoint* G4ITStepProcessor::fpPostStepPoint

private

Definition at line 422 of file G4ITStepProcessor.hh.

Referenced by CalculateSafety(), CleanProcessor(), DoStepping(), and SetupMembers().

fpPreStepPoint

G4StepPoint* G4ITStepProcessor::fpPreStepPoint

private

Definition at line 421 of file G4ITStepProcessor.hh.

Referenced by ApplyProductionCut(), CleanProcessor(), and SetupMembers().

fpProcessInfo

ProcessGeneralInfo* G4ITStepProcessor::fpProcessInfo

private

Definition at line 406 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), DoStepping(), FindTransportationStep(), GetAtRestIL(), GetCurrentProcessInfo(), GetProcessInfo(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePostStepDoItProcs(), InvokePSDIP(), InvokeTransportationProc(), and SetupGeneralProcessInfo().

fPreviousTimeStep

G4double G4ITStepProcessor::fPreviousTimeStep

private

Definition at line 361 of file G4ITStepProcessor.hh.

Referenced by G4ITStepProcessor(), and SetPreviousStepTime().

fProcessGeneralInfoMap

std::map<const G4ParticleDefinition*, ProcessGeneralInfo*> G4ITStepProcessor::fProcessGeneralInfoMap

private

Definition at line 405 of file G4ITStepProcessor.hh.

Referenced by ClearProcessInfo(), GetProcessInfo(), and SetupGeneralProcessInfo().

fpSecondary

G4TrackVector* G4ITStepProcessor::fpSecondary

private

Definition at line 362 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DealWithSecondaries(), ExtractDoItData(), GetSecondaries(), InitDefineStep(), PushSecondaries(), SetupMembers(), and ~G4ITStepProcessor().

fpState

G4ITStepProcessorState* G4ITStepProcessor::fpState

private

Definition at line 418 of file G4ITStepProcessor.hh.

Referenced by CalculateSafety(), CleanProcessor(), DoDefinePhysicalStepLength(), DoStepping(), FindTransportationStep(), GetAtRestIL(), GetProcessorState(), InitDefineStep(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePostStepDoItProcs(), InvokeTransportationProc(), SetInitialStep(), and SetupMembers().

fpStep

G4Step* G4ITStepProcessor::fpStep

private

Definition at line 419 of file G4ITStepProcessor.hh.

Referenced by ApplyProductionCut(), CleanProcessor(), DoDefinePhysicalStepLength(), DoStepping(), FindTransportationStep(), GetStep(), InitDefineStep(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePSDIP(), SetInitialStep(), SetStep(), SetTrack(), SetupMembers(), and ~G4ITStepProcessor().

fpTrack

G4Track* G4ITStepProcessor::fpTrack

private

Definition at line 414 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DealWithSecondaries(), DoDefinePhysicalStepLength(), DoStepping(), ExtractDoItData(), ExtractILData(), FindTransportationStep(), GetAtRestIL(), GetProcessInfo(), GetTrack(), InitDefineStep(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePostStepDoItProcs(), InvokePSDIP(), InvokeTransportationProc(), SetInitialStep(), and SetTrack().

fpTrackContainer

G4ITTrackHolder* G4ITStepProcessor::fpTrackContainer

private

Definition at line 350 of file G4ITStepProcessor.hh.

Referenced by ComputeInteractionLength(), DoIt(), G4ITStepProcessor(), Initialize(), and PushSecondaries().

fpTrackingInfo

G4TrackingInformation* G4ITStepProcessor::fpTrackingInfo

private

Definition at line 416 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), FindTransportationStep(), GetAtRestIL(), InvokeAlongStepDoItProcs(), InvokeAtRestDoItProcs(), InvokePSDIP(), and SetTrack().

fpTrackingManager

G4ITTrackingManager* G4ITStepProcessor::fpTrackingManager

private

Definition at line 341 of file G4ITStepProcessor.hh.

Referenced by DoIt(), DoStepping(), ExtractDoItData(), ExtractILData(), G4ITStepProcessor(), GetTrackingManager(), InitDefineStep(), Initialize(), and SetTrackingManager().

fpTransportation

G4ITTransportation* G4ITStepProcessor::fpTransportation

private

Definition at line 407 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), DoStepping(), and FindTransportationStep().

fpVerbose

G4VITSteppingVerbose* G4ITStepProcessor::fpVerbose

private

Definition at line 348 of file G4ITStepProcessor.hh.

Referenced by DoDefinePhysicalStepLength(), DoIt(), DoStepping(), G4ITStepProcessor(), Initialize(), InvokeAlongStepDoItProcs(), and InvokePSDIP().

fStoreTrajectory

G4int G4ITStepProcessor::fStoreTrajectory

private

Definition at line 347 of file G4ITStepProcessor.hh.

Referenced by G4ITStepProcessor().

fTimeStep

G4double G4ITStepProcessor::fTimeStep

private

Definition at line 358 of file G4ITStepProcessor.hh.

Referenced by CleanProcessor(), DoDefinePhysicalStepLength(), ExtractILData(), FindTransportationStep(), GetAtRestIL(), GetInteractionTime(), and Stepping().

kCarTolerance

G4double G4ITStepProcessor::kCarTolerance

private

Definition at line 343 of file G4ITStepProcessor.hh.

Referenced by CalculateSafety(), DoStepping(), G4ITStepProcessor(), and Initialize().

---

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

• source/processes/electromagnetic/dna/management/include/G4ITStepProcessor.hh
• source/processes/electromagnetic/dna/management/src/G4ITStepProcessor.cc
• source/processes/electromagnetic/dna/management/src/G4ITStepProcessor2.cc