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

Constructor & Destructor Documentation

G4ITStepProcessor() [1/2]

G4ITStepProcessor::G4ITStepProcessor

(

)

Definition at line 71 of file G4ITStepProcessor.cc.

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

Referenced by G4ITStepProcessor(), and operator=().

~G4ITStepProcessor()

G4ITStepProcessor::~G4ITStepProcessor ( )

virtual

Definition at line 223 of file G4ITStepProcessor.cc.

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

G4ITStepProcessor() [2/2]

G4ITStepProcessor::G4ITStepProcessor ( const G4ITStepProcessor & other )

protected

Definition at line 239 of file G4ITStepProcessor.cc.

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

Member Function Documentation

ActiveOnlyITProcess() [1/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( )

protected

Definition at line 284 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 == nullptr)
    {
      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 318 of file G4ITStepProcessor.cc.

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

ApplyProductionCut()

void G4ITStepProcessor::ApplyProductionCut ( G4Track * aSecondary )

protected

Definition at line 912 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 440 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 456 of file G4ITStepProcessor.hh.

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

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

ClearProcessInfo()

void G4ITStepProcessor::ClearProcessInfo ( )

protected

Definition at line 165 of file G4ITStepProcessor.cc.

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

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

ComputeInteractionLength()

G4double G4ITStepProcessor::ComputeInteractionLength

(

double

previousTimeStep

)

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

DealWithSecondaries()

void G4ITStepProcessor::DealWithSecondaries ( G4int & counter )

protected

Definition at line 63 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 693 of file G4ITStepProcessor.cc.

{
  SetTrack(track);
  DoDefinePhysicalStepLength();
}

Referenced by ComputeInteractionLength().

DoDefinePhysicalStepLength()

void G4ITStepProcessor::DoDefinePhysicalStepLength ( )

protected

Definition at line 951 of file G4ITStepProcessor.cc.

{
 
  InitDefineStep();
 
#ifdef G4VERBOSE
  // !!!!! Verbose
  if(fpVerbose != nullptr) 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(nullptr);
 
  // 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 == nullptr)
    {
      (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 != nullptr) 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 !!!
    }
    
    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 == nullptr) 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 != nullptr) 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 == nullptr)
        {
          G4ExceptionDescription exceptionDescription;
          exceptionDescription << "No transportation process found ";
          G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength",
                      "ITStepProcessor0009",
                      FatalErrorInArgument,
                      exceptionDescription);
        }
 
        fTimeStep = fpTransportation->GetInteractionTimeLeft();
 
        if(fpTrack->GetNextVolume() != nullptr) fpState->fStepStatus = fGeomBoundary;
        else fpState->fStepStatus = fWorldBoundary;
      }
    }
    else
    {
      if(kp == fpProcessInfo->MAXofAlongStepLoops - 1)
      {
        fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
 
        if(fpTransportation == nullptr)
        {
          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 110 of file G4ITStepProcessor2.cc.

{
  if(fpVerbose != nullptr) 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 == nullptr)
    {
      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();
}

DoStepping()

void G4ITStepProcessor::DoStepping ( )

protected

Definition at line 292 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 != nullptr) fpVerbose->PreStepVerbose(fpTrack);
#endif
 
  if(fpProcessInfo == nullptr)
  {
    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 != nullptr) 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
        != nullptr) // second condition to make coverity happy
    {
      //-----------------
      // AtRestStepDoIt
      //-----------------
      InvokeAtRestDoItProcs();
      fpState->fStepStatus = fAtRestDoItProc;
      fpStep->GetPostStepPoint()->SetStepStatus(fpState->fStepStatus);
 
#ifdef G4VERBOSE
            // !!!!! Verbose
      if(fpVerbose != nullptr) 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 == nullptr)
    {
      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())
    {
      // 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 != nullptr) 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 != nullptr) 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 != nullptr) 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 != nullptr) 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 191 of file G4ITStepProcessor2.cc.

{
  if (fpTrack == nullptr)
  {
    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 != nullptr)
      {
        for (auto & i : *fpSecondary)
        {
          delete 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 630 of file G4ITStepProcessor.cc.

{
  assert(fpTrack != 0);
  if (fpTrack == nullptr)
  {
    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;
  }
  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 801 of file G4ITStepProcessor2.cc.

{
  double physicalStep(0.);
 
  fpTransportation = fpProcessInfo->fpTransportation;
  // dynamic_cast<G4ITTransportation*>((fpProcessInfo->fpAlongStepGetPhysIntVector)[MAXofAlongStepLoops-1]);
 
  if(fpTrack == nullptr)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "No G4ITStepProcessor::fpTrack found";
    G4Exception("G4ITStepProcessor::FindTransportationStep",
                "ITStepProcessor0013",
                FatalErrorInArgument,
                exceptionDescription);
    return;
 
  }
  if(fpITrack == nullptr)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "No G4ITStepProcessor::fITrack";
    G4Exception("G4ITStepProcessor::FindTransportationStep",
                "ITStepProcessor0014",
                FatalErrorInArgument,
                exceptionDescription);
    return;
  }
  if((fpITrack->GetTrack()) == nullptr)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "No G4ITStepProcessor::fITrack->GetTrack()";
    G4Exception("G4ITStepProcessor::FindTransportationStep",
                "ITStepProcessor0015",
                FatalErrorInArgument,
                exceptionDescription);
    return;
  }
 
  if(fpTransportation != nullptr)
  {
    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 184 of file G4ITStepProcessor.cc.

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

GetAtRestDoItProcTriggered()

std::size_t G4ITStepProcessor::GetAtRestDoItProcTriggered ( ) const

inline

Definition at line 219 of file G4ITStepProcessor.hh.

  {
    return fAtRestDoItProcTriggered;
  }

GetAtRestIL()

void G4ITStepProcessor::GetAtRestIL ( )

protected

Definition at line 535 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== nullptr)
    {
      (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 284 of file G4ITStepProcessor.hh.

  {
    return fCondition;
  }

GetCurrentProcess()

const G4VITProcess * G4ITStepProcessor::GetCurrentProcess ( ) const

inline

Definition at line 244 of file G4ITStepProcessor.hh.

  {
    return fpCurrentProcess;
  }

GetCurrentProcessInfo()

const ProcessGeneralInfo * G4ITStepProcessor::GetCurrentProcessInfo ( ) const

inline

Definition at line 264 of file G4ITStepProcessor.hh.

  {
    return fpProcessInfo;
  }

GetCurrentVolume()

const G4VPhysicalVolume * G4ITStepProcessor::GetCurrentVolume ( ) const

inline

Definition at line 279 of file G4ITStepProcessor.hh.

  {
    return fpCurrentVolume;
  }

GetGPILSelection()

G4GPILSelection G4ITStepProcessor::GetGPILSelection ( ) const

inline

Definition at line 224 of file G4ITStepProcessor.hh.

  {
    return fGPILSelection;
  }

GetILTimeStep()

G4double G4ITStepProcessor::GetILTimeStep ( )

inline

Definition at line 202 of file G4ITStepProcessor.hh.

  {
    return fILTimeStep;
  }

GetInteractionTime()

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 490 of file G4ITStepProcessor.hh.

{
  return fTimeStep;
}

Referenced by ExtractILData().

GetN2ndariesAlongStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesAlongStepDoIt ( ) const

inline

Definition at line 229 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAlongStepDoIt;
  }

GetN2ndariesAtRestDoIt()

G4int G4ITStepProcessor::GetN2ndariesAtRestDoIt ( ) const

inline

Definition at line 234 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAtRestDoIt;
  }

GetN2ndariesPostStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesPostStepDoIt ( ) const

inline

Definition at line 239 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesPostStepDoIt;
  }

GetParticleChange()

const G4VParticleChange * G4ITStepProcessor::GetParticleChange ( ) const

inline

Definition at line 274 of file G4ITStepProcessor.hh.

  {
    return fpParticleChange;
  }

GetPhysIntLength()

G4double G4ITStepProcessor::GetPhysIntLength ( ) const

inline

Definition at line 249 of file G4ITStepProcessor.hh.

  {
    return fPhysIntLength;
  }

GetPostStepAtTimeDoItProcTriggered()

std::size_t G4ITStepProcessor::GetPostStepAtTimeDoItProcTriggered ( ) const

inline

Definition at line 254 of file G4ITStepProcessor.hh.

  {
    return fPostStepAtTimeDoItProcTriggered;
  }

GetPostStepDoItProcTriggered()

std::size_t G4ITStepProcessor::GetPostStepDoItProcTriggered ( ) const

inline

Definition at line 259 of file G4ITStepProcessor.hh.

  {
    return fPostStepDoItProcTriggered;
  }

GetProcessInfo()

void G4ITStepProcessor::GetProcessInfo ( )

protected

Definition at line 482 of file G4ITStepProcessor.cc.

{
  G4ParticleDefinition* particle = fpTrack->GetDefinition();
  auto it =
      fProcessGeneralInfoMap.find(particle);
 
  if(it == fProcessGeneralInfoMap.end())
  {
    SetupGeneralProcessInfo(particle,
                            fpTrack->GetDefinition()->GetProcessManager());
    if(fpProcessInfo == nullptr)
    {
      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 269 of file G4ITStepProcessor.hh.

  {
    return fpState;
  }

GetSecondaries()

G4TrackVector * G4ITStepProcessor::GetSecondaries ( ) const

inline

Definition at line 178 of file G4ITStepProcessor.hh.

  {
    return fpSecondary;
  }

GetStep() [1/2]

G4Step * G4ITStepProcessor::GetStep ( )

inline

Definition at line 165 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

GetStep() [2/2]

const G4Step * G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 169 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

GetTrack() [1/2]

G4Track * G4ITStepProcessor::GetTrack ( )

inline

Definition at line 161 of file G4ITStepProcessor.hh.

  {
    return fpTrack;
  }

GetTrack() [2/2]

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 433 of file G4ITStepProcessor.hh.

{
  return fpTrack;
}

GetTrackingManager()

G4ITTrackingManager * G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 186 of file G4ITStepProcessor.hh.

  {
    return fpTrackingManager;
  }

InitDefineStep()

void G4ITStepProcessor::InitDefineStep ( )

protected

ADDED BACK

ADDED BACK

Definition at line 845 of file G4ITStepProcessor.cc.

{
 
  if(fpStep == nullptr)
  {
    // 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(nullptr);
 
    // 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 193 of file G4ITStepProcessor.cc.

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

Referenced by ForceReInitialization().

InvokeAlongStepDoItProcs()

void G4ITStepProcessor::InvokeAlongStepDoItProcs ( )

protected

Definition at line 627 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 == nullptr) 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 != nullptr) 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 560 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 711 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 761 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 != nullptr) 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 862 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 275 of file G4ITStepProcessor.cc.

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

PrepareLeadingTracks()

void G4ITStepProcessor::PrepareLeadingTracks

(

)

Definition at line 268 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.PrepareLeadingTracks();
}

PushSecondaries()

void G4ITStepProcessor::PushSecondaries ( )

protected

Definition at line 240 of file G4ITStepProcessor2.cc.

{
  if ((fpSecondary == nullptr) || fpSecondary->empty())
  {
    // DEBUG
    //      G4cout << "NO SECONDARIES !!! " << G4endl;
    return;
  }
 
  // DEBUG
  //    G4cout << "There are secondaries : "<< secondaries -> size() << G4endl ;
 
  auto 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 261 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.Reset();
}

ResetSecondaries()

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 525 of file G4ITStepProcessor.cc.

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

Referenced by G4ITStepProcessor(), G4ITStepProcessor(), and SetupMembers().

SetInitialStep()

void G4ITStepProcessor::SetInitialStep ( )

protected

Definition at line 701 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() != nullptr)
    {
      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 == nullptr)
  {
    // 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 449 of file G4ITStepProcessor.hh.

{
  fpNavigator = value;
}

Referenced by Initialize().

SetPreviousStepTime()

void G4ITStepProcessor::SetPreviousStepTime ( G4double previousTimeStep )

inline

Definition at line 426 of file G4ITStepProcessor.hh.

{
  fPreviousTimeStep = previousTimeStep;
}

Referenced by ComputeInteractionLength().

SetStep()

void G4ITStepProcessor::SetStep ( G4Step * val )

inline

Definition at line 173 of file G4ITStepProcessor.hh.

  {
    fpStep = val;
  }

SetTrack()

void G4ITStepProcessor::SetTrack ( G4Track * track )

protected

Definition at line 449 of file G4ITStepProcessor.cc.

{
  fpTrack = track;
  if(fpTrack != nullptr)
  {
    fpITrack = GetIT(fpTrack);
    fpStep = const_cast<G4Step*>(fpTrack->GetStep());
 
    if(fpITrack != nullptr)
    {
      fpTrackingInfo = fpITrack->GetTrackingInfo();
    }
    else
    {
      fpTrackingInfo = nullptr;
      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 = nullptr;
    fpStep = nullptr;
  }
}

Referenced by DefinePhysicalStepLength(), and Stepping().

SetTrackingManager()

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager * trackMan )

inline

Definition at line 182 of file G4ITStepProcessor.hh.

  {
    fpTrackingManager = trackMan;
  }

SetupGeneralProcessInfo()

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

protected

Definition at line 338 of file G4ITStepProcessor.cc.

{
 
#ifdef debug
  G4cout<<"G4ITStepProcessor::GetProcessNumber: is called track"<<G4endl;
#endif
  if(pm == nullptr)
  {
    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;
  }
 
  auto 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 == nullptr) &&
      (fpProcessInfo->fpAlongStepDoItVector == nullptr) &&
      (fpProcessInfo->fpPostStepDoItVector == nullptr))
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "No DoIt process found ";
    G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0005",
        FatalErrorInArgument,exceptionDescription);
    return;
  }
 
  if((fpProcessInfo->fpAlongStepGetPhysIntVector != nullptr)
      && fpProcessInfo->MAXofAlongStepLoops>0)
  {
    fpProcessInfo->fpTransportation = dynamic_cast<G4ITTransportation*>
    ((*fpProcessInfo->fpAlongStepGetPhysIntVector)
        [G4int(fpProcessInfo->MAXofAlongStepLoops-1)]);
 
    if(fpProcessInfo->fpTransportation == nullptr)
    {
      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 510 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 263 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 == nullptr) return; // maybe put an exception here
  fTimeStep = timeStep;
  SetTrack(track);
  DoStepping();
}

Referenced by DoIt().

Friends And Related Symbol Documentation

G4Scheduler

friend class G4Scheduler

friend

Definition at line 154 of file G4ITStepProcessor.hh.

Referenced by G4Scheduler.

---

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

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