G4ITStepProcessor Class Reference

#include <G4ITStepProcessor.hh>

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

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

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

~G4ITStepProcessor()

G4ITStepProcessor::~G4ITStepProcessor ( )

virtual

Definition at line 227 of file G4ITStepProcessor.cc.

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

G4ITStepProcessor() [2/2]

G4ITStepProcessor::G4ITStepProcessor ( const G4ITStepProcessor &  other )

protected

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

Member Function Documentation

ActiveOnlyITProcess() [1/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( )

protected

Definition at line 288 of file G4ITStepProcessor.cc.

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

Referenced by ActiveOnlyITProcess().

ActiveOnlyITProcess() [2/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( G4ProcessManager *  processManager )

protected

Definition at line 322 of file G4ITStepProcessor.cc.

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

ApplyProductionCut()

void G4ITStepProcessor::ApplyProductionCut ( G4Track *  aSecondary )

protected

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

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

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

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

ClearProcessInfo()

void G4ITStepProcessor::ClearProcessInfo ( )

protected

Definition at line 169 of file G4ITStepProcessor.cc.

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

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

ComputeInteractionLength()

G4double G4ITStepProcessor::ComputeInteractionLength

(

double

previousTimeStep

)

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

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
}

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

DefinePhysicalStepLength()

void G4ITStepProcessor::DefinePhysicalStepLength

(

G4Track *

track

)

Definition at line 697 of file G4ITStepProcessor.cc.

{
  SetTrack(track);
  DoDefinePhysicalStepLength();
}

Referenced by ComputeInteractionLength().

DoDefinePhysicalStepLength()

void G4ITStepProcessor::DoDefinePhysicalStepLength ( )

protected

Definition at line 955 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
 
  G4double 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(std::size_t np = 0; np < fpProcessInfo->MAXofPostStepLoops; ++np)
  {
    fpCurrentProcess = dynamic_cast<G4VITProcess*>((*fpProcessInfo
        ->fpPostStepGetPhysIntVector)[(G4int)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(std::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(std::size_t kp = 0; kp < fpProcessInfo->MAXofAlongStepLoops; ++kp)
  {
    fpCurrentProcess = dynamic_cast<G4VITProcess*>((*fpProcessInfo
        ->fpAlongStepGetPhysIntVector)[(G4int)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();
}

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--;
  std::size_t initialSize = mainList->size();
 
//    G4cout << "initialSize = " << initialSize << G4endl;
 
  for(std::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();
}

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

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 (std::size_t i = 0; i < fpSecondary->size(); ++i)
        {
          delete (*fpSecondary)[i];
        }
        fpSecondary->clear();
      }
//      G4TrackList::Pop(fpTrack);
      fpTrackingManager->EndTracking(fpTrack);
//      fTrackContainer->PushToKill(fpTrack);
      break;
  }
 
  CleanProcessor();
}

Referenced by DoIt().

ExtractILData()

void G4ITStepProcessor::ExtractILData ( )

protected

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

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

Referenced by DoStepping().

ForceReInitialization()

void G4ITStepProcessor::ForceReInitialization

(

)

Definition at line 188 of file G4ITStepProcessor.cc.

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

GetAtRestDoItProcTriggered()

std::size_t G4ITStepProcessor::GetAtRestDoItProcTriggered ( ) const

inline

Definition at line 220 of file G4ITStepProcessor.hh.

  {
    return fAtRestDoItProcTriggered;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetAtRestIL()

void G4ITStepProcessor::GetAtRestIL ( )

protected

Definition at line 539 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( G4int ri=0; ri < (G4int)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;
  }
}

Referenced by DoDefinePhysicalStepLength().

GetCondition()

G4ForceCondition G4ITStepProcessor::GetCondition ( ) const

inline

Definition at line 285 of file G4ITStepProcessor.hh.

  {
    return fCondition;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetCurrentProcess()

const G4VITProcess * G4ITStepProcessor::GetCurrentProcess ( ) const

inline

Definition at line 245 of file G4ITStepProcessor.hh.

  {
    return fpCurrentProcess;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetCurrentProcessInfo()

const ProcessGeneralInfo * G4ITStepProcessor::GetCurrentProcessInfo ( ) const

inline

Definition at line 265 of file G4ITStepProcessor.hh.

  {
    return fpProcessInfo;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetCurrentVolume()

const G4VPhysicalVolume * G4ITStepProcessor::GetCurrentVolume ( ) const

inline

Definition at line 280 of file G4ITStepProcessor.hh.

  {
    return fpCurrentVolume;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetGPILSelection()

G4GPILSelection G4ITStepProcessor::GetGPILSelection ( ) const

inline

Definition at line 225 of file G4ITStepProcessor.hh.

  {
    return fGPILSelection;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetILTimeStep()

G4double G4ITStepProcessor::GetILTimeStep ( )

inline

Definition at line 203 of file G4ITStepProcessor.hh.

  {
    return fILTimeStep;
  }

GetInteractionTime()

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 491 of file G4ITStepProcessor.hh.

{
  return fTimeStep;
}

Referenced by ExtractILData().

GetN2ndariesAlongStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesAlongStepDoIt ( ) const

inline

Definition at line 230 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAlongStepDoIt;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetN2ndariesAtRestDoIt()

G4int G4ITStepProcessor::GetN2ndariesAtRestDoIt ( ) const

inline

Definition at line 235 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAtRestDoIt;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetN2ndariesPostStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesPostStepDoIt ( ) const

inline

Definition at line 240 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesPostStepDoIt;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetParticleChange()

const G4VParticleChange * G4ITStepProcessor::GetParticleChange ( ) const

inline

Definition at line 275 of file G4ITStepProcessor.hh.

  {
    return fpParticleChange;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetPhysIntLength()

G4double G4ITStepProcessor::GetPhysIntLength ( ) const

inline

Definition at line 250 of file G4ITStepProcessor.hh.

  {
    return fPhysIntLength;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetPostStepAtTimeDoItProcTriggered()

std::size_t G4ITStepProcessor::GetPostStepAtTimeDoItProcTriggered ( ) const

inline

Definition at line 255 of file G4ITStepProcessor.hh.

  {
    return fPostStepAtTimeDoItProcTriggered;
  }

GetPostStepDoItProcTriggered()

std::size_t G4ITStepProcessor::GetPostStepDoItProcTriggered ( ) const

inline

Definition at line 260 of file G4ITStepProcessor.hh.

  {
    return fPostStepDoItProcTriggered;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetProcessInfo()

void G4ITStepProcessor::GetProcessInfo ( )

protected

Definition at line 486 of file G4ITStepProcessor.cc.

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

Referenced by SetupMembers().

GetProcessorState()

const G4ITStepProcessorState * G4ITStepProcessor::GetProcessorState ( ) const

inline

Definition at line 270 of file G4ITStepProcessor.hh.

  {
    return fpState;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetSecondaries()

G4TrackVector * G4ITStepProcessor::GetSecondaries ( ) const

inline

Definition at line 179 of file G4ITStepProcessor.hh.

  {
    return fpSecondary;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetStep() [1/2]

G4Step * G4ITStepProcessor::GetStep ( )

inline

Definition at line 166 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetStep() [2/2]

const G4Step * G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 170 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

GetTrack() [1/2]

G4Track * G4ITStepProcessor::GetTrack ( )

inline

Definition at line 162 of file G4ITStepProcessor.hh.

  {
    return fpTrack;
  }

Referenced by G4VITSteppingVerbose::CopyState().

GetTrack() [2/2]

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 434 of file G4ITStepProcessor.hh.

{
  return fpTrack;
}

GetTrackingManager()

G4ITTrackingManager * G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 187 of file G4ITStepProcessor.hh.

  {
    return fpTrackingManager;
  }

InitDefineStep()

void G4ITStepProcessor::InitDefineStep ( )

protected

ADDED BACK

ADDED BACK

Definition at line 849 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);
 
    //! ADDED BACK
    /*
     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);
     }
 
     */
    //! ADDED BACK
    //==========================================================================
    // Only reset navigator state + reset volume hierarchy (internal)
    // No need to relocate
    //==========================================================================
    fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()
        ->GetNavigatorState());
  }
}

Referenced by DoDefinePhysicalStepLength().

Initialize()

void G4ITStepProcessor::Initialize ( )

virtual

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

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(std::size_t ci = 0; ci < fpProcessInfo->MAXofAlongStepLoops; ++ci)
  {
    fpCurrentProcess =
        (G4VITProcess*) (*fpProcessInfo->fpAlongStepDoItVector)[(G4int)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 );
  }
 
}

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(std::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)[(G4int)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(std::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);
}

Referenced by DoStepping().

InvokePostStepDoItProcs()

void G4ITStepProcessor::InvokePostStepDoItProcs ( )

protected

Definition at line 712 of file G4ITStepProcessor2.cc.

{
  std::size_t _MAXofPostStepLoops = fpProcessInfo->MAXofPostStepLoops;
  G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState
      ->fSelectedPostStepDoItVector;
  G4StepStatus& stepStatus = fpState->fStepStatus;
 
  // Invoke the specified discrete processes
  for(std::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(std::size_t np1 = np + 1; np1 < _MAXofPostStepLoops; ++np1)
      {
        G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops
                                                 - np1 - 1];
        if(Cond2 == StronglyForced)
        {
          InvokePSDIP(np1);
        }
      }
      break;
    }
  } //for(std::size_t np=0; np < MAXofPostStepLoops; ++np){
}

Referenced by DoStepping().

InvokePSDIP()

void G4ITStepProcessor::InvokePSDIP ( std::size_t  np )

protected

Definition at line 762 of file G4ITStepProcessor2.cc.

{
  fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepDoItVector)[(G4int)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();
}

Referenced by InvokePostStepDoItProcs(), and InvokeTransportationProc().

InvokeTransportationProc()

void G4ITStepProcessor::InvokeTransportationProc ( )

protected

Definition at line 863 of file G4ITStepProcessor2.cc.

{
  std::size_t _MAXofPostStepLoops = fpProcessInfo->MAXofPostStepLoops;
  G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState
      ->fSelectedPostStepDoItVector;
  G4StepStatus& stepStatus = fpState->fStepStatus;
 
  // Invoke the specified discrete processes
  for(std::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(std::size_t np1 = np + 1; np1 < _MAXofPostStepLoops; ++np1)
      {
        G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops - np1 - 1];
        if(Cond2 == StronglyForced)
        {
          InvokePSDIP(np1);
        }
      }
      break;
    }
  }
}

Referenced by DoStepping().

operator=()

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

protected

Definition at line 279 of file G4ITStepProcessor.cc.

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

PrepareLeadingTracks()

void G4ITStepProcessor::PrepareLeadingTracks

(

)

Definition at line 272 of file G4ITStepProcessor.cc.

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

Referenced by ExtractDoItData().

ResetLeadingTracks()

void G4ITStepProcessor::ResetLeadingTracks

(

)

Definition at line 265 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.Reset();
}

Referenced by G4Scheduler::Stepping().

ResetSecondaries()

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 529 of file G4ITStepProcessor.cc.

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

Referenced by G4ITStepProcessor(), and SetupMembers().

SetInitialStep()

void G4ITStepProcessor::SetInitialStep ( )

protected

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

Referenced by InitDefineStep().

SetNavigator()

void G4ITStepProcessor::SetNavigator ( G4ITNavigator *  value )

inlineprotected

Definition at line 450 of file G4ITStepProcessor.hh.

{
  fpNavigator = value;
}

Referenced by Initialize().

SetPreviousStepTime()

void G4ITStepProcessor::SetPreviousStepTime ( G4double  previousTimeStep )

inline

Definition at line 427 of file G4ITStepProcessor.hh.

{
  fPreviousTimeStep = previousTimeStep;
}

Referenced by ComputeInteractionLength().

SetStep()

void G4ITStepProcessor::SetStep ( G4Step *  val )

inline

Definition at line 174 of file G4ITStepProcessor.hh.

  {
    fpStep = val;
  }

SetTrack()

void G4ITStepProcessor::SetTrack ( G4Track *  track )

protected

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

Referenced by DefinePhysicalStepLength(), and Stepping().

SetTrackingManager()

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager *  trackMan )

inline

Definition at line 183 of file G4ITStepProcessor.hh.

  {
    fpTrackingManager = trackMan;
  }

Referenced by G4Scheduler::Initialize().

SetupGeneralProcessInfo()

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

protected

Definition at line 342 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)
        [G4int(fpProcessInfo->MAXofAlongStepLoops-1)]);
 
    if(fpProcessInfo->fpTransportation == 0)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "No transportation process found ";
      G4Exception("G4ITStepProcessor::SetupGeneralProcessInfo",
          "ITStepProcessor0006",
          FatalErrorInArgument,exceptionDescription);
    }
  }
  fProcessGeneralInfoMap[particle] = fpProcessInfo;
  //    fpProcessInfo = 0;
}

Referenced by GetProcessInfo().

SetupMembers()

void G4ITStepProcessor::SetupMembers ( )

protected

Definition at line 514 of file G4ITStepProcessor.cc.

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

Referenced by DoStepping(), and InitDefineStep().

Stepping()

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

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

Referenced by DoIt().

Friends And Related Function Documentation

G4Scheduler

friend class G4Scheduler

friend

Definition at line 155 of file G4ITStepProcessor.hh.

---

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

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