G4ITStepProcessor Class Reference

#include <G4ITStepProcessor.hh>

Collaboration diagram for G4ITStepProcessor:

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 ()
size_t	GetAtRestDoItProcTriggered () const
G4GPILSelection	GetGPILSelection () const
G4int	GetN2ndariesAlongStepDoIt () const
G4int	GetN2ndariesAtRestDoIt () const
G4int	GetN2ndariesPostStepDoIt () const
const G4VITProcess *	GetCurrentProcess () const
G4double	GetPhysIntLength () const
size_t	GetPostStepAtTimeDoItProcTriggered () const
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 (size_t)
void	InvokeTransportationProc ()
void	SetNavigator (G4ITNavigator *value)
G4double	CalculateSafety ()
void	ApplyProductionCut (G4Track *)
	G4ITStepProcessor (const G4ITStepProcessor &other)
G4ITStepProcessor &	operator= (const G4ITStepProcessor &other)

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

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

Constructor & Destructor Documentation

G4ITStepProcessor() [1/2]

G4ITStepProcessor::G4ITStepProcessor

(

)

Definition at line 77 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 229 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 245 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 290 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);
  }
}

Here is the call graph for this function:

ActiveOnlyITProcess() [2/2]

void G4ITStepProcessor::ActiveOnlyITProcess ( G4ProcessManager *  processManager )

protected

Definition at line 324 of file G4ITStepProcessor.cc.

{
  // Method not used for the time being
  G4ProcessVector* processVector = processManager->GetProcessList();

  G4VITProcess* itProcess = 0;
  for(int i = 0; i < processVector->size(); i++)
  {
    G4VProcess* base_process = (*processVector)[i];
    itProcess = dynamic_cast<G4VITProcess*>(base_process);

    if(!itProcess)
    {
      processManager->SetProcessActivation(base_process, false);
    }
  }
}

Here is the call graph for this function:

ApplyProductionCut()

void G4ITStepProcessor::ApplyProductionCut ( G4Track *  aSecondary )

protected

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

Here is the call graph for this function:

CalculateSafety()

G4double G4ITStepProcessor::CalculateSafety ( )

inlineprotected

Definition at line 442 of file G4ITStepProcessor.hh.

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

CleanProcessor()

void G4ITStepProcessor::CleanProcessor ( )

inline

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

ClearProcessInfo()

void G4ITStepProcessor::ClearProcessInfo ( )

protected

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

ComputeInteractionLength()

G4double G4ITStepProcessor::ComputeInteractionLength

(

double

previousTimeStep

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

DealWithSecondaries()

void G4ITStepProcessor::DealWithSecondaries ( G4int &  counter )

protected

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

Here is the call graph for this function:

DefinePhysicalStepLength()

void G4ITStepProcessor::DefinePhysicalStepLength

(

G4Track *

track

)

Definition at line 699 of file G4ITStepProcessor.cc.

{
  SetTrack(track);
  DoDefinePhysicalStepLength();
}

DoDefinePhysicalStepLength()

void G4ITStepProcessor::DoDefinePhysicalStepLength ( )

protected

Definition at line 956 of file G4ITStepProcessor.cc.

{

  InitDefineStep();

#ifdef G4VERBOSE
  // !!!!! Verbose
  if(fpVerbose) fpVerbose->DPSLStarted();
#endif

  G4TrackStatus trackStatus = fpTrack->GetTrackStatus();

  if(trackStatus == fStopAndKill)
  {
    return;
  }

  if(trackStatus == fStopButAlive)
  {
    fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator
        ->GetNavigatorState());
    fpNavigator->ResetNavigatorState();
    return GetAtRestIL();
  }

  // Find minimum Step length and corresponding time
  // demanded by active disc./cont. processes

  // ReSet the counter etc.
  fpState->fPhysicalStep = DBL_MAX; // Initialize by a huge number
  fPhysIntLength = DBL_MAX; // Initialize by a huge number

  double proposedTimeStep = DBL_MAX;
  G4VProcess* processWithPostStepGivenByTimeStep(0);

  // GPIL for PostStep
  fPostStepDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
  fPostStepAtTimeDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;

  //  G4cout << "fpProcessInfo->MAXofPostStepLoops : "
  //         << fpProcessInfo->MAXofPostStepLoops
  //         << " mol : " << fpITrack -> GetName()
  //         << " id : " << fpTrack->GetTrackID()
  //         << G4endl;

  for(size_t np = 0; np < fpProcessInfo->MAXofPostStepLoops; np++)
  {
    fpCurrentProcess = dynamic_cast<G4VITProcess*>((*fpProcessInfo
        ->fpPostStepGetPhysIntVector)[np]);
    if(fpCurrentProcess == 0)
    {
      (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
      continue;
    } // NULL means the process is inactivated by a user on fly.

    fCondition = NotForced;
    fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess
        ->GetProcessID()));

    // G4cout << "Is going to call : "
    //        << fpCurrentProcess -> GetProcessName()
    //        << G4endl;
    fPhysIntLength = fpCurrentProcess->PostStepGPIL(*fpTrack,
                                                    fpState->fPreviousStepSize,
                                                    &fCondition);

#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->DPSLPostStep();
#endif

    fpCurrentProcess->ResetProcessState();
    //fpCurrentProcess->SetProcessState(0);

    switch(fCondition)
    {
      case ExclusivelyForced: // Will need special treatment
        (fpState->fSelectedPostStepDoItVector)[np] = ExclusivelyForced;
        fpState->fStepStatus = fExclusivelyForcedProc;
        fpStep->GetPostStepPoint()->SetProcessDefinedStep(fpCurrentProcess);
        break;

      case Conditionally:
        //       (fpState->fSelectedPostStepDoItVector)[np] = Conditionally;
        G4Exception("G4ITStepProcessor::DefinePhysicalStepLength()",
                    "ITStepProcessor0008",
                    FatalException,
                    "This feature is no more supported");
        break;

      case Forced:
        (fpState->fSelectedPostStepDoItVector)[np] = Forced;
        break;

      case StronglyForced:
        (fpState->fSelectedPostStepDoItVector)[np] = StronglyForced;
        break;

      default:
        (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
        break;
    }

    if(fCondition == ExclusivelyForced)
    {
      for(size_t nrest = np + 1; nrest < fpProcessInfo->MAXofPostStepLoops;
          nrest++)
      {
        (fpState->fSelectedPostStepDoItVector)[nrest] = InActivated;
      }
      return; // Please note the 'return' at here !!!
    }
    else
    {
      if(fPhysIntLength < fpState->fPhysicalStep)
      {
        // To avoid checking whether the process is actually
        // proposing a time step, the returned time steps are
        // negative (just for tagging)
        if(fpCurrentProcess->ProposesTimeStep())
        {
          fPhysIntLength *= -1;
          if(fPhysIntLength < proposedTimeStep)
          {
            proposedTimeStep = fPhysIntLength;
            fPostStepAtTimeDoItProcTriggered = np;
            processWithPostStepGivenByTimeStep = fpCurrentProcess;
          }
        }
        else
        {
          fpState->fPhysicalStep = fPhysIntLength;
          fpState->fStepStatus = fPostStepDoItProc;
          fPostStepDoItProcTriggered = G4int(np);
          fpStep->GetPostStepPoint()->SetProcessDefinedStep(fpCurrentProcess);
        }
      }
    }
  }

  // GPIL for AlongStep
  fpState->fProposedSafety = DBL_MAX;
  G4double safetyProposedToAndByProcess = fpState->fProposedSafety;

  for(size_t kp = 0; kp < fpProcessInfo->MAXofAlongStepLoops; kp++)
  {
    fpCurrentProcess = dynamic_cast<G4VITProcess*>((*fpProcessInfo
        ->fpAlongStepGetPhysIntVector)[kp]);
    if(fpCurrentProcess == 0) continue;
    // NULL means the process is inactivated by a user on fly.

    fpCurrentProcess->SetProcessState(
        fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
    fPhysIntLength =
        fpCurrentProcess->AlongStepGPIL(*fpTrack,
                                        fpState->fPreviousStepSize,
                                        fpState->fPhysicalStep,
                                        safetyProposedToAndByProcess,
                                        &fGPILSelection);

#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->DPSLAlongStep();
#endif

    if(fPhysIntLength < fpState->fPhysicalStep)
    {
      fpState->fPhysicalStep = fPhysIntLength;
      // Should save PS and TS in IT

      // Check if the process wants to be the GPIL winner. For example,
      // multi-scattering proposes Step limit, but won't be the winner.
      if(fGPILSelection == CandidateForSelection)
      {
        fpState->fStepStatus = fAlongStepDoItProc;
        fpStep->GetPostStepPoint()->SetProcessDefinedStep(fpCurrentProcess);
      }

      // Transportation is assumed to be the last process in the vector
      if(kp == fpProcessInfo->MAXofAlongStepLoops - 1)
      {
        fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);

        if(!fpTransportation)
        {
          G4ExceptionDescription exceptionDescription;
          exceptionDescription << "No transportation process found ";
          G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength",
                      "ITStepProcessor0009",
                      FatalErrorInArgument,
                      exceptionDescription);
        }

        fTimeStep = fpTransportation->GetInteractionTimeLeft();

        if(fpTrack->GetNextVolume() != 0) fpState->fStepStatus = fGeomBoundary;
        else fpState->fStepStatus = fWorldBoundary;
      }
    }
    else
    {
      if(kp == fpProcessInfo->MAXofAlongStepLoops - 1)
      {
        fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);

        if(!fpTransportation)
        {
          G4ExceptionDescription exceptionDescription;
          exceptionDescription << "No transportation process found ";
          G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength",
                      "ITStepProcessor0010",
                      FatalErrorInArgument,
                      exceptionDescription);
        }

        fTimeStep = fpTransportation->GetInteractionTimeLeft();
      }
    }

    // Handle PostStep processes sending back time steps rather than space length
    if(proposedTimeStep < fTimeStep)
    {
      if(fPostStepAtTimeDoItProcTriggered < fpProcessInfo->MAXofPostStepLoops)
      {
        if((fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] == InActivated)
        {
          (fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] =
              NotForced;
          // (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] = InActivated;

          fpState->fStepStatus = fPostStepDoItProc;
          fpStep->GetPostStepPoint()->SetProcessDefinedStep(processWithPostStepGivenByTimeStep);

          fTimeStep = proposedTimeStep;

          fpTransportation->ComputeStep(*fpTrack,
                                        *fpStep,
                                        fTimeStep,
                                        fpState->fPhysicalStep);
        }
      }
    }
    else
    {
      if(fPostStepDoItProcTriggered < fpProcessInfo->MAXofPostStepLoops)
      {
        if((fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] == InActivated)
        {
          (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] =
              NotForced;
        }
      }
    }

//  fpCurrentProcess->SetProcessState(0);
    fpCurrentProcess->ResetProcessState();

    // Make sure to check the safety, even if Step is not limited
    //  by this process.                      J. Apostolakis, June 20, 1998
    //
    if(safetyProposedToAndByProcess < fpState->fProposedSafety)
    // proposedSafety keeps the smallest value:
    fpState->fProposedSafety = safetyProposedToAndByProcess;
    else
    // safetyProposedToAndByProcess always proposes a valid safety:
    safetyProposedToAndByProcess = fpState->fProposedSafety;

  }

  fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
  fpNavigator->ResetNavigatorState();
}

Here is the call graph for this function:

DoIt()

void G4ITStepProcessor::DoIt

(

double

timeStep

)

Definition at line 112 of file G4ITStepProcessor2.cc.

{
  if(fpVerbose) fpVerbose->DoItStarted();

  G4TrackManyList* mainList = fpTrackContainer->GetMainList();
  G4TrackManyList::iterator it = mainList->end();
  it--;
  size_t initialSize = mainList->size();

  //  G4cout << "initialSize = " << initialSize << G4endl;

  for(size_t i = 0 ; i < initialSize ; ++i)
  {

    //  G4cout << "i = " << i << G4endl;

    G4Track* track = *it;
    if (!track)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "No track was pop back the main track list.";
      G4Exception("G4ITStepProcessor::DoIt", "NO_TRACK",
                  FatalException, exceptionDescription);
    }
    // G4TrackManyList::iterator next_it (it);
    // next_it--;
    // it = next_it;

    it--;
    // Must be called before EndTracking(track)
    // Otherwise the iterator will point to the list of killed tracks

    if(track->GetTrackStatus() == fStopAndKill)
    {
      fpTrackingManager->EndTracking(track);
//      G4cout << GetIT(track)->GetName() << G4endl;
//      G4cout << " ************************ CONTINUE ********************" << G4endl;
      continue;
    }

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DOIT)
    MemStat mem_first, mem_second, mem_diff;
    mem_first = MemoryUsage();
#endif

    Stepping(track, timeStep);

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DOIT)
    MemStat mem_intermediaire = MemoryUsage();
    mem_diff = mem_intermediaire-mem_first;
    G4cout << "\t\t >> || MEM || In DoIT with track "
        << track->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif

    ExtractDoItData();

#if defined (DEBUG_MEM) && defined (DEBUG_MEM_DOIT)
    mem_second = MemoryUsage();
    mem_diff = mem_second-mem_first;
    G4cout << "\t >> || MEM || In DoIT with track "
        << track->GetTrackID()
        << ", diff is : " << mem_diff << G4endl;
#endif
  }


  fpTrackContainer->MergeSecondariesWithMainList();
  fpTrackContainer->KillTracks(); // (18-06-15 : MK) Remove it ?
  fLeadingTracks.Reset();
}

Here is the call graph for this function:

Here is the caller graph for this function:

DoStepping()

void G4ITStepProcessor::DoStepping ( )

protected

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

Here is the call graph for this function:

ExtractDoItData()

void G4ITStepProcessor::ExtractDoItData

(

)

Definition at line 193 of file G4ITStepProcessor2.cc.

{
  if (!fpTrack)
  {
    CleanProcessor();
    return;
  }

  G4TrackStatus status = fpTrack->GetTrackStatus();

  switch (status)
  {
    case fAlive:
    case fStopButAlive:
    case fSuspend:
    case fPostponeToNextEvent:
    default:
      PushSecondaries();
      break;

    case fStopAndKill:
      G4ITReactionSet::Instance()->RemoveReactionSet(fpTrack);
      PushSecondaries();
//      G4TrackList::Pop(fpTrack);
      fpTrackingManager->EndTracking(fpTrack);
//      fTrackContainer->PushToKill(fpTrack);
      break;

    case fKillTrackAndSecondaries:
      G4ITReactionSet::Instance()->RemoveReactionSet(fpTrack);
      if (fpSecondary)
      {
        for (size_t i = 0; i < fpSecondary->size(); ++i)
        {
          delete (*fpSecondary)[i];
        }
        fpSecondary->clear();
      }
//      G4TrackList::Pop(fpTrack);
      fpTrackingManager->EndTracking(fpTrack);
//      fTrackContainer->PushToKill(fpTrack);
      break;
  }

  CleanProcessor();
}

Here is the call graph for this function:

ExtractILData()

void G4ITStepProcessor::ExtractILData ( )

protected

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

Here is the call graph for this function:

FindTransportationStep()

void G4ITStepProcessor::FindTransportationStep

(

)

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

Here is the call graph for this function:

ForceReInitialization()

void G4ITStepProcessor::ForceReInitialization

(

)

Definition at line 190 of file G4ITStepProcessor.cc.

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

Here is the call graph for this function:

GetAtRestDoItProcTriggered()

size_t G4ITStepProcessor::GetAtRestDoItProcTriggered ( ) const

inline

Definition at line 221 of file G4ITStepProcessor.hh.

  {
    return fAtRestDoItProcTriggered;
  }

Here is the caller graph for this function:

GetAtRestIL()

void G4ITStepProcessor::GetAtRestIL ( )

protected

Definition at line 541 of file G4ITStepProcessor.cc.

{
  // Select the rest process which has the shortest time before
  // it is invoked. In rest processes, GPIL()
  // returns the time before a process occurs.
  G4double lifeTime(DBL_MAX), shortestLifeTime (DBL_MAX);

  fAtRestDoItProcTriggered = 0;
  shortestLifeTime = DBL_MAX;

  unsigned int NofInactiveProc=0;

  for( size_t ri=0; ri < fpProcessInfo->MAXofAtRestLoops; ri++ )
  {
    fpCurrentProcess = dynamic_cast<G4VITProcess*>((*fpProcessInfo->fpAtRestGetPhysIntVector)[ri]);
    if (fpCurrentProcess== 0)
    {
      (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
      NofInactiveProc++;
      continue;
    } // NULL means the process is inactivated by a user on fly.

    fCondition=NotForced;
    fpCurrentProcess->SetProcessState(
        fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));

    lifeTime = fpCurrentProcess->AtRestGPIL( *fpTrack, &fCondition );
    fpCurrentProcess->ResetProcessState();

    if(fCondition==Forced)
    {
      (fpState->fSelectedAtRestDoItVector)[ri] = Forced;
    }
    else
    {
      (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
      if(lifeTime < shortestLifeTime )
      {
        shortestLifeTime = lifeTime;
        fAtRestDoItProcTriggered = G4int(ri);
      }
    }
  }

  (fpState->fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;

//  G4cout << " --> Selected at rest process : "
//         << (*fpProcessInfo->fpAtRestGetPhysIntVector)[fAtRestDoItProcTriggered]
//            ->GetProcessName()
//         << G4endl;

  fTimeStep = shortestLifeTime;

  // at least one process is necessary to destroy the particle
  // exit with warning
  if(NofInactiveProc==fpProcessInfo->MAXofAtRestLoops)
  {
    G4cerr << "ERROR - G4ITStepProcessor::InvokeAtRestDoItProcs()" << G4endl
    << "        No AtRestDoIt process is active!" << G4endl;
  }
}

Here is the call graph for this function:

GetCondition()

G4ForceCondition G4ITStepProcessor::GetCondition ( ) const

inline

Definition at line 286 of file G4ITStepProcessor.hh.

  {
    return fCondition;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

GetCurrentProcess()

const G4VITProcess* G4ITStepProcessor::GetCurrentProcess ( ) const

inline

Definition at line 246 of file G4ITStepProcessor.hh.

  {
    return fpCurrentProcess;
  }

Here is the caller graph for this function:

GetCurrentProcessInfo()

const ProcessGeneralInfo* G4ITStepProcessor::GetCurrentProcessInfo ( ) const

inline

Definition at line 266 of file G4ITStepProcessor.hh.

  {
    return fpProcessInfo;
  }

Here is the caller graph for this function:

GetCurrentVolume()

const G4VPhysicalVolume* G4ITStepProcessor::GetCurrentVolume ( ) const

inline

Definition at line 281 of file G4ITStepProcessor.hh.

  {
    return fpCurrentVolume;
  }

Here is the caller graph for this function:

GetGPILSelection()

G4GPILSelection G4ITStepProcessor::GetGPILSelection ( ) const

inline

Definition at line 226 of file G4ITStepProcessor.hh.

  {
    return fGPILSelection;
  }

Here is the caller graph for this function:

GetILTimeStep()

G4double G4ITStepProcessor::GetILTimeStep ( )

inline

Definition at line 204 of file G4ITStepProcessor.hh.

  {
    return fILTimeStep;
  }

Here is the call graph for this function:

GetInteractionTime()

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 492 of file G4ITStepProcessor.hh.

{
  return fTimeStep;
}

GetN2ndariesAlongStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesAlongStepDoIt ( ) const

inline

Definition at line 231 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAlongStepDoIt;
  }

Here is the caller graph for this function:

GetN2ndariesAtRestDoIt()

G4int G4ITStepProcessor::GetN2ndariesAtRestDoIt ( ) const

inline

Definition at line 236 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAtRestDoIt;
  }

Here is the caller graph for this function:

GetN2ndariesPostStepDoIt()

G4int G4ITStepProcessor::GetN2ndariesPostStepDoIt ( ) const

inline

Definition at line 241 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesPostStepDoIt;
  }

Here is the caller graph for this function:

GetParticleChange()

const G4VParticleChange* G4ITStepProcessor::GetParticleChange ( ) const

inline

Definition at line 276 of file G4ITStepProcessor.hh.

  {
    return fpParticleChange;
  }

Here is the caller graph for this function:

GetPhysIntLength()

G4double G4ITStepProcessor::GetPhysIntLength ( ) const

inline

Definition at line 251 of file G4ITStepProcessor.hh.

  {
    return fPhysIntLength;
  }

Here is the caller graph for this function:

GetPostStepAtTimeDoItProcTriggered()

size_t G4ITStepProcessor::GetPostStepAtTimeDoItProcTriggered ( ) const

inline

Definition at line 256 of file G4ITStepProcessor.hh.

  {
    return fPostStepAtTimeDoItProcTriggered;
  }

GetPostStepDoItProcTriggered()

size_t G4ITStepProcessor::GetPostStepDoItProcTriggered ( ) const

inline

Definition at line 261 of file G4ITStepProcessor.hh.

  {
    return fPostStepDoItProcTriggered;
  }

Here is the caller graph for this function:

GetProcessInfo()

void G4ITStepProcessor::GetProcessInfo ( )

protected

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

Here is the call graph for this function:

GetProcessorState()

const G4ITStepProcessorState* G4ITStepProcessor::GetProcessorState ( ) const

inline

Definition at line 271 of file G4ITStepProcessor.hh.

  {
    return fpState;
  }

Here is the caller graph for this function:

GetSecondaries()

G4TrackVector* G4ITStepProcessor::GetSecondaries ( ) const

inline

Definition at line 180 of file G4ITStepProcessor.hh.

  {
    return fpSecondary;
  }

Here is the caller graph for this function:

GetStep() [1/2]

G4Step* G4ITStepProcessor::GetStep ( )

inline

Definition at line 167 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

Here is the caller graph for this function:

GetStep() [2/2]

const G4Step* G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 171 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

GetTrack() [1/2]

G4Track* G4ITStepProcessor::GetTrack ( )

inline

Definition at line 163 of file G4ITStepProcessor.hh.

  {
    return fpTrack;
  }

Here is the caller graph for this function:

GetTrack() [2/2]

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 435 of file G4ITStepProcessor.hh.

{
  return fpTrack;
}

GetTrackingManager()

G4ITTrackingManager* G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 188 of file G4ITStepProcessor.hh.

  {
    return fpTrackingManager;
  }

Here is the call graph for this function:

InitDefineStep()

void G4ITStepProcessor::InitDefineStep ( )

protected

ADDED BACK

ADDED BACK

Definition at line 850 of file G4ITStepProcessor.cc.

{

  if(!fpStep)
  {
    // Create new Step and give it to the track
    fpStep = new G4Step();
    fpTrack->SetStep(fpStep);
    fpSecondary = fpStep->NewSecondaryVector();

    // Create new state and set it in the trackingInfo
    fpState = new G4ITStepProcessorState();
    fpITrack->GetTrackingInfo()->SetStepProcessorState((G4ITStepProcessorState_Lock*) fpState);

    SetupMembers();
    SetInitialStep();

    fpTrackingManager->StartTracking(fpTrack);
  }
  else
  {
    SetupMembers();

    fpState->fPreviousStepSize = fpTrack->GetStepLength();
    /***
     // Send G4Step information to Hit/Dig if the volume is sensitive
     fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
     StepControlFlag =  fpStep->GetControlFlag();
     if( fpCurrentVolume != 0 && StepControlFlag != AvoidHitInvocation)
     {
     fpSensitive = fpStep->GetPreStepPoint()->
     GetSensitiveDetector();

     //            if( fSensitive != 0 ) {
     //              fSensitive->Hit(fStep);
     //            }
     }
     ***/
    // Store last PostStepPoint to PreStepPoint, and swap current and next
    // volume information of G4Track. Reset total energy deposit in one Step.
    fpStep->CopyPostToPreStepPoint();
    fpStep->ResetTotalEnergyDeposit();

    //JA Set the volume before it is used (in DefineStepLength() for User Limit)
    fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
    /*
     G4cout << G4endl;
     G4cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
     G4cout << "PreStepPoint Volume : "
     << fpCurrentVolume->GetName() << G4endl;
     G4cout << "Track Touchable : "
     << fpTrack->GetTouchableHandle()->GetVolume()->GetName() << G4endl;
     G4cout << "Track NextTouchable : "
     << fpTrack->GetNextTouchableHandle()->GetVolume()->GetName()
     << G4endl;
     */
    // Reset the step's auxiliary points vector pointer
    fpStep->SetPointerToVectorOfAuxiliaryPoints(0);

    // Switch next touchable in track to current one
    fpTrack->SetTouchableHandle(fpTrack->GetNextTouchableHandle());
    fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
    fpTrack->SetNextTouchableHandle(fpState->fTouchableHandle);

    /*
     G4VPhysicalVolume* oldTopVolume =
     fpTrack->GetTouchableHandle()->GetVolume();
     fpNavigator->SetNavigatorState(
     fpITrack->GetTrackingInfo()->GetNavigatorState());

     G4VPhysicalVolume* newTopVolume = fpNavigator->ResetHierarchyAndLocate(
     fpTrack->GetPosition(), fpTrack->GetMomentumDirection(),
     *((G4TouchableHistory*) fpTrack->GetTouchableHandle()()));

     //  G4VPhysicalVolume* newTopVolume=
     //     fpNavigator->LocateGlobalPointAndSetup(fpTrack->GetPosition(),
     //                                            &fpTrack->GetMomentumDirection(),
     //                                            true, false);

     //        G4cout << "New Top Volume : " << newTopVolume->GetName() << G4endl;

     if (newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId()
     == 1)
     {
     fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
     fpTrack->SetTouchableHandle(fpState->fTouchableHandle);
     fpTrack->SetNextTouchableHandle(fpState->fTouchableHandle);
     }

     */
    //==========================================================================
    // Only reset navigator state + reset volume hierarchy (internal)
    // No need to relocate
    //==========================================================================
    fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()
        ->GetNavigatorState());
  }
}

Here is the call graph for this function:

Initialize()

void G4ITStepProcessor::Initialize ( )

virtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

InvokeAlongStepDoItProcs()

void G4ITStepProcessor::InvokeAlongStepDoItProcs ( )

protected

Definition at line 629 of file G4ITStepProcessor2.cc.

{

#ifdef DEBUG_MEM
  MemStat mem_first, mem_second, mem_diff;
#endif

#ifdef DEBUG_MEM
  mem_first = MemoryUsage();
#endif

  // If the current Step is defined by a 'ExclusivelyForced'
  // PostStepDoIt, then don't invoke any AlongStepDoIt
  if(fpState->fStepStatus == fExclusivelyForcedProc)
  {
    return;               // Take note 'return' at here !!!
  }

  // Invoke the all active continuous processes
  for(size_t ci = 0; ci < fpProcessInfo->MAXofAlongStepLoops; ci++)
  {
    fpCurrentProcess =
        (G4VITProcess*) (*fpProcessInfo->fpAlongStepDoItVector)[ci];
    if(fpCurrentProcess == 0) continue;
    // NULL means the process is inactivated by a user on fly.

    fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess
        ->GetProcessID()));
    fpParticleChange = fpCurrentProcess->AlongStepDoIt(*fpTrack, *fpStep);

#ifdef DEBUG_MEM
    MemStat mem_intermediaire = MemoryUsage();
    mem_diff = mem_intermediaire-mem_first;
    G4cout << "\t\t\t >> || MEM || After calling AlongStepDoIt for " << fpCurrentProcess->GetProcessName() << " and track "<< fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif

//        fpCurrentProcess->SetProcessState(0);
    fpCurrentProcess->ResetProcessState();
    // Update the PostStepPoint of Step according to ParticleChange

    fpParticleChange->UpdateStepForAlongStep(fpStep);

#ifdef G4VERBOSE
    // !!!!! Verbose
    if(fpVerbose) fpVerbose->AlongStepDoItOneByOne();
#endif

    // Now Store the secondaries from ParticleChange to SecondaryList
    DealWithSecondaries(fN2ndariesAlongStepDoIt);

    // Set the track status according to what the process defined
    // if kinetic energy >0, otherwise set  fStopButAlive
    fpTrack->SetTrackStatus(fpParticleChange->GetTrackStatus());

    // clear ParticleChange
    fpParticleChange->Clear();
  }

#ifdef DEBUG_MEM
  MemStat mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || After looping on processes with " << fpTrack->GetTrackID() << ", diff is : " << mem_diff << G4endl;
#endif

  fpStep->UpdateTrack();

  G4TrackStatus fNewStatus = fpTrack->GetTrackStatus();

  if(fNewStatus == fAlive && fpTrack->GetKineticEnergy() <= DBL_MIN)
  {
    //        G4cout << "G4ITStepProcessor::InvokeAlongStepDoItProcs : Track will be killed" << G4endl;
    if(fpProcessInfo->MAXofAtRestLoops>0) fNewStatus = fStopButAlive;
    else fNewStatus = fStopAndKill;
    fpTrack->SetTrackStatus( fNewStatus );
  }

}

Here is the call graph for this function:

InvokeAtRestDoItProcs()

void G4ITStepProcessor::InvokeAtRestDoItProcs ( )

protected

Definition at line 562 of file G4ITStepProcessor2.cc.

{
  fpStep->SetStepLength(0.);  //the particle has stopped
  fpTrack->SetStepLength(0.);

  G4SelectedAtRestDoItVector& selectedAtRestDoItVector =
      fpState->fSelectedAtRestDoItVector;

  // invoke selected process
  for(size_t np = 0; np < fpProcessInfo->MAXofAtRestLoops; np++)
  {
    //
    // Note: DoItVector has inverse order against GetPhysIntVector
    //       and SelectedAtRestDoItVector.
    //
    if(selectedAtRestDoItVector[fpProcessInfo->MAXofAtRestLoops - np - 1] != InActivated)
    {
      fpCurrentProcess =
          (G4VITProcess*) (*fpProcessInfo->fpAtRestDoItVector)[np];

//      G4cout << " Invoke : "
//             << fpCurrentProcess->GetProcessName()
//             << G4endl;

      //  if(fpVerbose)
      //  {
      //    fpVerbose->AtRestDoItOneByOne();
      //  }

      fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess
          ->GetProcessID()));
      fpParticleChange = fpCurrentProcess->AtRestDoIt(*fpTrack, *fpStep);
      fpCurrentProcess->ResetProcessState();

      // Set the current process as a process which defined this Step length
      fpStep->GetPostStepPoint()->SetProcessDefinedStep(fpCurrentProcess);

      // Update Step
      fpParticleChange->UpdateStepForAtRest(fpStep);

      // Now Store the secondaries from ParticleChange to SecondaryList
      DealWithSecondaries(fN2ndariesAtRestDoIt);

      // Set the track status according to what the process defined
      // if kinetic energy >0, otherwise set  fStopButAlive
      fpTrack->SetTrackStatus(fpParticleChange->GetTrackStatus());

      // clear ParticleChange
      fpParticleChange->Clear();

    } //if(fSelectedAtRestDoItVector[np] != InActivated){
  } //for(size_t np=0; np < MAXofAtRestLoops; np++){
  fpStep->UpdateTrack();

  // Modification par rapport au transport standard :
  // fStopAndKill doit etre propose par le modele
  // sinon d autres processus AtRest seront appeles
  // au pas suivant
  // fpTrack->SetTrackStatus(fStopAndKill);
}

InvokePostStepDoItProcs()

void G4ITStepProcessor::InvokePostStepDoItProcs ( )

protected

Definition at line 713 of file G4ITStepProcessor2.cc.

{
  size_t _MAXofPostStepLoops = fpProcessInfo->MAXofPostStepLoops;
  G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState
      ->fSelectedPostStepDoItVector;
  G4StepStatus& stepStatus = fpState->fStepStatus;

  // Invoke the specified discrete processes
  for(size_t np = 0; np < _MAXofPostStepLoops; np++)
  {
    //
    // Note: DoItVector has inverse order against GetPhysIntVector
    //       and SelectedPostStepDoItVector.
    //
    G4int Cond = selectedPostStepDoItVector[_MAXofPostStepLoops
                                            - np - 1];
    if(Cond != InActivated)
    {
      if(((Cond == NotForced) && (stepStatus == fPostStepDoItProc)) ||
          ((Cond == Forced) && (stepStatus != fExclusivelyForcedProc))
         ||
         // ((Cond == Conditionally) && (stepStatus == fAlongStepDoItProc)) ||
         ((Cond == ExclusivelyForced) && (stepStatus == fExclusivelyForcedProc))
         || ((Cond == StronglyForced)))
      {

        InvokePSDIP(np);
      }
    } //if(*fSelectedPostStepDoItVector(np)........

    // Exit from PostStepLoop if the track has been killed,
    // but extra treatment for processes with Strongly Forced flag
    if(fpTrack->GetTrackStatus() == fStopAndKill)
    {
      for(size_t np1 = np + 1; np1 < _MAXofPostStepLoops; np1++)
      {
        G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops
                                                 - np1 - 1];
        if(Cond2 == StronglyForced)
        {
          InvokePSDIP(np1);
        }
      }
      break;
    }
  } //for(size_t np=0; np < MAXofPostStepLoops; np++){
}

InvokePSDIP()

void G4ITStepProcessor::InvokePSDIP ( size_t  np )

protected

Definition at line 763 of file G4ITStepProcessor2.cc.

{
  fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepDoItVector)[np];

  fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess
      ->GetProcessID()));
  fpParticleChange = fpCurrentProcess->PostStepDoIt(*fpTrack, *fpStep);
//    fpCurrentProcess->SetProcessState(0);
  fpCurrentProcess->ResetProcessState();

  // Update PostStepPoint of Step according to ParticleChange
  fpParticleChange->UpdateStepForPostStep(fpStep);

#ifdef G4VERBOSE
  // !!!!! Verbose
  if(fpVerbose) fpVerbose->PostStepDoItOneByOne();
#endif

  // Update G4Track according to ParticleChange after each PostStepDoIt
  fpStep->UpdateTrack();

  // Update safety after each invocation of PostStepDoIts
  fpStep->GetPostStepPoint()->SetSafety(CalculateSafety());

  // Now Store the secondaries from ParticleChange to SecondaryList
  DealWithSecondaries(fN2ndariesPostStepDoIt);

  // Set the track status according to what the process defined
  fpTrack->SetTrackStatus(fpParticleChange->GetTrackStatus());

  // clear ParticleChange
  fpParticleChange->Clear();
}

InvokeTransportationProc()

void G4ITStepProcessor::InvokeTransportationProc ( )

protected

Definition at line 864 of file G4ITStepProcessor2.cc.

{
  size_t _MAXofPostStepLoops = fpProcessInfo->MAXofPostStepLoops;
  G4SelectedPostStepDoItVector& selectedPostStepDoItVector = fpState
      ->fSelectedPostStepDoItVector;
  G4StepStatus& stepStatus = fpState->fStepStatus;

  // Invoke the specified discrete processes
  for(size_t np = 0; np < _MAXofPostStepLoops; np++)
  {
    //
    // Note: DoItVector has inverse order against GetPhysIntVector
    //       and SelectedPostStepDoItVector.
    //
    G4int Cond = selectedPostStepDoItVector[_MAXofPostStepLoops - np - 1];
    if(Cond != InActivated)
    {
      if(((Cond == Forced) && (stepStatus != fExclusivelyForcedProc)) ||
      // ((Cond == Conditionally) && (stepStatus == fAlongStepDoItProc)) ||
      ((Cond == ExclusivelyForced) && (stepStatus == fExclusivelyForcedProc))
         || ((Cond == StronglyForced)))
      {

        InvokePSDIP(np);
      }
    } //if(Cond != InActivated)

    // Exit from PostStepLoop if the track has been killed,
    // but extra treatment for processes with Strongly Forced flag
    if(fpTrack->GetTrackStatus() == fStopAndKill)
    {
      for(size_t np1 = np + 1; np1 < _MAXofPostStepLoops; np1++)
      {
        G4int Cond2 = selectedPostStepDoItVector[_MAXofPostStepLoops - np1 - 1];
        if(Cond2 == StronglyForced)
        {
          InvokePSDIP(np1);
        }
      }
      break;
    }
  }
}

operator=()

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

protected

Definition at line 281 of file G4ITStepProcessor.cc.

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

PrepareLeadingTracks()

void G4ITStepProcessor::PrepareLeadingTracks

(

)

Definition at line 274 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.PrepareLeadingTracks();
}

Here is the caller graph for this function:

PushSecondaries()

void G4ITStepProcessor::PushSecondaries ( )

protected

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

ResetLeadingTracks()

void G4ITStepProcessor::ResetLeadingTracks

(

)

Definition at line 267 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.Reset();
}

Here is the caller graph for this function:

ResetSecondaries()

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 531 of file G4ITStepProcessor.cc.

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

SetInitialStep()

void G4ITStepProcessor::SetInitialStep ( )

protected

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

  // If the primary track has 'zero' kinetic energy, set the track
  // state to 'StopButAlive'.
  if(fpTrack->GetKineticEnergy() <= 0.0)
  {
    fpTrack->SetTrackStatus(fStopButAlive);
  }
  //________________________________________________________
  // Set vertex information of G4Track at here
  if(fpTrack->GetCurrentStepNumber() == 0)
  {
    fpTrack->SetVertexPosition(fpTrack->GetPosition());
    fpTrack->SetVertexMomentumDirection(fpTrack->GetMomentumDirection());
    fpTrack->SetVertexKineticEnergy(fpTrack->GetKineticEnergy());
    fpTrack->SetLogicalVolumeAtVertex(fpTrack->GetVolume()->GetLogicalVolume());
  }
  //________________________________________________________
  // If track is already outside the world boundary, kill it
  if(fpCurrentVolume == 0)
  {
    // If the track is a primary, stop processing
    if(fpTrack->GetParentID() == 0)
    {
      G4cerr << "ERROR - G4ITStepProcessor::SetInitialStep()" << G4endl<< "        Primary particle starting at - "
      << fpTrack->GetPosition()
      << " - is outside of the world volume." << G4endl;
      G4Exception("G4ITStepProcessor::SetInitialStep()", "ITStepProcessor0011",
          FatalException, "Primary vertex outside of the world!");
    }

    fpTrack->SetTrackStatus( fStopAndKill );
    G4cout << "WARNING - G4ITStepProcessor::SetInitialStep()" << G4endl
    << "          Initial track position is outside world! - "
    << fpTrack->GetPosition() << G4endl;
  }
  else
  {
    // Initial set up for attribues of 'Step'
    fpStep->InitializeStep( fpTrack );
  }

  if(fpTrack->GetTrackStatus() == fStopAndKill) return;

  fpState->fStepStatus = fUndefined;
}

Here is the call graph for this function:

SetNavigator()

void G4ITStepProcessor::SetNavigator ( G4ITNavigator *  value )

inlineprotected

Definition at line 451 of file G4ITStepProcessor.hh.

{
  fpNavigator = value;
}

SetPreviousStepTime()

void G4ITStepProcessor::SetPreviousStepTime ( G4double  previousTimeStep )

inline

Definition at line 428 of file G4ITStepProcessor.hh.

{
  fPreviousTimeStep = previousTimeStep;
}

SetStep()

void G4ITStepProcessor::SetStep ( G4Step *  val )

inline

Definition at line 175 of file G4ITStepProcessor.hh.

  {
    fpStep = val;
  }

SetTrack()

void G4ITStepProcessor::SetTrack ( G4Track *  track )

protected

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

Here is the call graph for this function:

SetTrackingManager()

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager *  trackMan )

inline

Definition at line 184 of file G4ITStepProcessor.hh.

  {
    fpTrackingManager = trackMan;
  }

Here is the caller graph for this function:

SetupGeneralProcessInfo()

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

protected

Definition at line 344 of file G4ITStepProcessor.cc.

{

#ifdef debug
  G4cout<<"G4ITStepProcessor::GetProcessNumber: is called track"<<G4endl;
#endif
  if(!pm)
  {
    G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl<< "        ProcessManager is NULL for particle = "
    << particle->GetParticleName() << ", PDG_code = "
    << particle->GetPDGEncoding() << G4endl;
    G4Exception("G4SteppingManager::GetProcessNumber()", "ITStepProcessor0002",
        FatalException, "Process Manager is not found.");
    return;
  }

  std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it =
  fProcessGeneralInfoMap.find(particle);
  if(it != fProcessGeneralInfoMap.end())
  {
    G4Exception("G4SteppingManager::SetupGeneralProcessInfo()",
        "ITStepProcessor0003",
        FatalException, "Process info already registered.");
    return;
  }

  // here used as temporary
  fpProcessInfo = new ProcessGeneralInfo();

  // AtRestDoits
  fpProcessInfo->MAXofAtRestLoops = pm->GetAtRestProcessVector()->entries();
  fpProcessInfo->fpAtRestDoItVector = pm->GetAtRestProcessVector(typeDoIt);
  fpProcessInfo->fpAtRestGetPhysIntVector =
  pm->GetAtRestProcessVector(typeGPIL);
#ifdef debug
  G4cout << "G4ITStepProcessor::GetProcessNumber: #ofAtRest="
  << fpProcessInfo->MAXofAtRestLoops << G4endl;
#endif

  // AlongStepDoits
  fpProcessInfo->MAXofAlongStepLoops =
  pm->GetAlongStepProcessVector()->entries();
  fpProcessInfo->fpAlongStepDoItVector =
  pm->GetAlongStepProcessVector(typeDoIt);
  fpProcessInfo->fpAlongStepGetPhysIntVector =
  pm->GetAlongStepProcessVector(typeGPIL);
#ifdef debug
  G4cout << "G4ITStepProcessor::GetProcessNumber:#ofAlongStp="
  << fpProcessInfo->MAXofAlongStepLoops << G4endl;
#endif

  // PostStepDoits
  fpProcessInfo->MAXofPostStepLoops =
  pm->GetPostStepProcessVector()->entries();
  fpProcessInfo->fpPostStepDoItVector = pm->GetPostStepProcessVector(typeDoIt);
  fpProcessInfo->fpPostStepGetPhysIntVector =
  pm->GetPostStepProcessVector(typeGPIL);
#ifdef debug
  G4cout << "G4ITStepProcessor::GetProcessNumber: #ofPostStep="
  << fpProcessInfo->MAXofPostStepLoops << G4endl;
#endif

  if (SizeOfSelectedDoItVector<fpProcessInfo->MAXofAtRestLoops ||
      SizeOfSelectedDoItVector<fpProcessInfo->MAXofAlongStepLoops ||
      SizeOfSelectedDoItVector<fpProcessInfo->MAXofPostStepLoops )
  {
    G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
    << "        SizeOfSelectedDoItVector= " << SizeOfSelectedDoItVector
    << " ; is smaller then one of MAXofAtRestLoops= "
    << fpProcessInfo->MAXofAtRestLoops << G4endl
    << "        or MAXofAlongStepLoops= " << fpProcessInfo->MAXofAlongStepLoops
    << " or MAXofPostStepLoops= " << fpProcessInfo->MAXofPostStepLoops << G4endl;
    G4Exception("G4ITStepProcessor::GetProcessNumber()",
        "ITStepProcessor0004", FatalException,
        "The array size is smaller than the actual No of processes.");
  }

  if(!fpProcessInfo->fpAtRestDoItVector &&
      !fpProcessInfo->fpAlongStepDoItVector &&
      !fpProcessInfo->fpPostStepDoItVector)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "No DoIt process found ";
    G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0005",
        FatalErrorInArgument,exceptionDescription);
    return;
  }

  if(fpProcessInfo->fpAlongStepGetPhysIntVector
      && fpProcessInfo->MAXofAlongStepLoops>0)
  {
    fpProcessInfo->fpTransportation = dynamic_cast<G4ITTransportation*>
    ((*fpProcessInfo->fpAlongStepGetPhysIntVector)
        [fpProcessInfo->MAXofAlongStepLoops-1]);

    if(fpProcessInfo->fpTransportation == 0)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "No transportation process found ";
      G4Exception("G4ITStepProcessor::SetupGeneralProcessInfo",
          "ITStepProcessor0006",
          FatalErrorInArgument,exceptionDescription);
    }
  }
  fProcessGeneralInfoMap[particle] = fpProcessInfo;
  //    fpProcessInfo = 0;
}

Here is the call graph for this function:

SetupMembers()

void G4ITStepProcessor::SetupMembers ( )

protected

Definition at line 516 of file G4ITStepProcessor.cc.

{
  fpSecondary = fpStep->GetfSecondary();
  fpPreStepPoint = fpStep->GetPreStepPoint();
  fpPostStepPoint = fpStep->GetPostStepPoint();

  fpState = (G4ITStepProcessorState*) fpITrack->GetTrackingInfo()
      ->GetStepProcessorState();

  GetProcessInfo();
  ResetSecondaries();
}

Stepping()

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

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

Here is the call graph for this function:

Friends And Related Function Documentation

G4Scheduler

friend class G4Scheduler

friend

Definition at line 156 of file G4ITStepProcessor.hh.

Member Data Documentation

fAtRestDoItProcTriggered

size_t G4ITStepProcessor::fAtRestDoItProcTriggered

private

Definition at line 378 of file G4ITStepProcessor.hh.

fCondition

G4ForceCondition G4ITStepProcessor::fCondition

private

Definition at line 383 of file G4ITStepProcessor.hh.

fGPILSelection

G4GPILSelection G4ITStepProcessor::fGPILSelection

private

Definition at line 384 of file G4ITStepProcessor.hh.

fILTimeStep

G4double G4ITStepProcessor::fILTimeStep

private

Definition at line 360 of file G4ITStepProcessor.hh.

fInitialized

G4bool G4ITStepProcessor::fInitialized

private

Definition at line 340 of file G4ITStepProcessor.hh.

fLeadingTracks

G4ITLeadingTracks G4ITStepProcessor::fLeadingTracks

private

Definition at line 352 of file G4ITStepProcessor.hh.

fN2ndariesAlongStepDoIt

G4int G4ITStepProcessor::fN2ndariesAlongStepDoIt

private

Definition at line 372 of file G4ITStepProcessor.hh.

fN2ndariesAtRestDoIt

G4int G4ITStepProcessor::fN2ndariesAtRestDoIt

private

Definition at line 371 of file G4ITStepProcessor.hh.

fN2ndariesPostStepDoIt

G4int G4ITStepProcessor::fN2ndariesPostStepDoIt

private

Definition at line 373 of file G4ITStepProcessor.hh.

fpCurrentProcess

G4VITProcess* G4ITStepProcessor::fpCurrentProcess

private

Definition at line 366 of file G4ITStepProcessor.hh.

fpCurrentVolume

G4VPhysicalVolume* G4ITStepProcessor::fpCurrentVolume

private

Definition at line 397 of file G4ITStepProcessor.hh.

fPhysIntLength

G4double G4ITStepProcessor::fPhysIntLength

private

Definition at line 390 of file G4ITStepProcessor.hh.

fpITrack

G4IT* G4ITStepProcessor::fpITrack

private

Definition at line 416 of file G4ITStepProcessor.hh.

fpNavigator

G4ITNavigator* G4ITStepProcessor::fpNavigator

private

Definition at line 347 of file G4ITStepProcessor.hh.

fPostStepAtTimeDoItProcTriggered

size_t G4ITStepProcessor::fPostStepAtTimeDoItProcTriggered

private

Definition at line 380 of file G4ITStepProcessor.hh.

fPostStepDoItProcTriggered

size_t G4ITStepProcessor::fPostStepDoItProcTriggered

private

Definition at line 379 of file G4ITStepProcessor.hh.

fpParticleChange

G4VParticleChange* G4ITStepProcessor::fpParticleChange

private

Definition at line 364 of file G4ITStepProcessor.hh.

fpPostStepPoint

G4StepPoint* G4ITStepProcessor::fpPostStepPoint

private

Definition at line 423 of file G4ITStepProcessor.hh.

fpPreStepPoint

G4StepPoint* G4ITStepProcessor::fpPreStepPoint

private

Definition at line 422 of file G4ITStepProcessor.hh.

fpProcessInfo

ProcessGeneralInfo* G4ITStepProcessor::fpProcessInfo

private

Definition at line 407 of file G4ITStepProcessor.hh.

fPreviousTimeStep

G4double G4ITStepProcessor::fPreviousTimeStep

private

Definition at line 362 of file G4ITStepProcessor.hh.

fProcessGeneralInfoMap

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

private

Definition at line 406 of file G4ITStepProcessor.hh.

fpSecondary

G4TrackVector* G4ITStepProcessor::fpSecondary

private

Definition at line 363 of file G4ITStepProcessor.hh.

fpState

G4ITStepProcessorState* G4ITStepProcessor::fpState

private

Definition at line 419 of file G4ITStepProcessor.hh.

fpStep

G4Step* G4ITStepProcessor::fpStep

private

Definition at line 420 of file G4ITStepProcessor.hh.

fpTrack

G4Track* G4ITStepProcessor::fpTrack

private

Definition at line 415 of file G4ITStepProcessor.hh.

fpTrackContainer

G4ITTrackHolder* G4ITStepProcessor::fpTrackContainer

private

Definition at line 351 of file G4ITStepProcessor.hh.

fpTrackingInfo

G4TrackingInformation* G4ITStepProcessor::fpTrackingInfo

private

Definition at line 417 of file G4ITStepProcessor.hh.

fpTrackingManager

G4ITTrackingManager* G4ITStepProcessor::fpTrackingManager

private

Definition at line 342 of file G4ITStepProcessor.hh.

fpTransportation

G4ITTransportation* G4ITStepProcessor::fpTransportation

private

Definition at line 408 of file G4ITStepProcessor.hh.

fpVerbose

G4VITSteppingVerbose* G4ITStepProcessor::fpVerbose

private

Definition at line 349 of file G4ITStepProcessor.hh.

fStoreTrajectory

G4int G4ITStepProcessor::fStoreTrajectory

private

Definition at line 348 of file G4ITStepProcessor.hh.

fTimeStep

G4double G4ITStepProcessor::fTimeStep

private

Definition at line 359 of file G4ITStepProcessor.hh.

kCarTolerance

G4double G4ITStepProcessor::kCarTolerance

private

Definition at line 344 of file G4ITStepProcessor.hh.

---

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

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