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 ()
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)

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::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 ( )

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Member Function Documentation

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:

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:

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:

G4double G4ITStepProcessor::CalculateSafety ( )

inlineprotected

Definition at line 442 of file G4ITStepProcessor.hh.

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

Here is the call graph for this function:

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

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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:

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:

void G4ITStepProcessor::DefinePhysicalStepLength

(

G4Track *

track

)

Definition at line 699 of file G4ITStepProcessor.cc.

{
  SetTrack(track);
  DoDefinePhysicalStepLength();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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:

Here is the caller graph for this function:

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:

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:

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:

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:

Here is the caller graph for this function:

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:

void G4ITStepProcessor::ForceReInitialization

(

)

Definition at line 190 of file G4ITStepProcessor.cc.

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

Here is the call graph for this function:

size_t G4ITStepProcessor::GetAtRestDoItProcTriggered ( ) const

inline

Definition at line 221 of file G4ITStepProcessor.hh.

  {
    return fAtRestDoItProcTriggered;
  }

Here is the caller graph for this function:

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:

Here is the caller graph for this function:

G4ForceCondition G4ITStepProcessor::GetCondition ( ) const

inline

Definition at line 286 of file G4ITStepProcessor.hh.

  {
    return fCondition;
  }

Here is the caller graph for this function:

const G4VITProcess* G4ITStepProcessor::GetCurrentProcess ( ) const

inline

Definition at line 246 of file G4ITStepProcessor.hh.

  {
    return fpCurrentProcess;
  }

Here is the caller graph for this function:

const ProcessGeneralInfo* G4ITStepProcessor::GetCurrentProcessInfo ( ) const

inline

Definition at line 266 of file G4ITStepProcessor.hh.

  {
    return fpProcessInfo;
  }

Here is the caller graph for this function:

const G4VPhysicalVolume* G4ITStepProcessor::GetCurrentVolume ( ) const

inline

Definition at line 281 of file G4ITStepProcessor.hh.

  {
    return fpCurrentVolume;
  }

Here is the caller graph for this function:

G4GPILSelection G4ITStepProcessor::GetGPILSelection ( ) const

inline

Definition at line 226 of file G4ITStepProcessor.hh.

  {
    return fGPILSelection;
  }

Here is the caller graph for this function:

G4double G4ITStepProcessor::GetILTimeStep ( )

inline

Definition at line 204 of file G4ITStepProcessor.hh.

  {
    return fILTimeStep;
  }

double G4ITStepProcessor::GetInteractionTime ( )

inline

Definition at line 492 of file G4ITStepProcessor.hh.

{
  return fTimeStep;
}

Here is the caller graph for this function:

G4int G4ITStepProcessor::GetN2ndariesAlongStepDoIt ( ) const

inline

Definition at line 231 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAlongStepDoIt;
  }

Here is the caller graph for this function:

G4int G4ITStepProcessor::GetN2ndariesAtRestDoIt ( ) const

inline

Definition at line 236 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesAtRestDoIt;
  }

Here is the caller graph for this function:

G4int G4ITStepProcessor::GetN2ndariesPostStepDoIt ( ) const

inline

Definition at line 241 of file G4ITStepProcessor.hh.

  {
    return fN2ndariesPostStepDoIt;
  }

Here is the caller graph for this function:

const G4VParticleChange* G4ITStepProcessor::GetParticleChange ( ) const

inline

Definition at line 276 of file G4ITStepProcessor.hh.

  {
    return fpParticleChange;
  }

Here is the caller graph for this function:

G4double G4ITStepProcessor::GetPhysIntLength ( ) const

inline

Definition at line 251 of file G4ITStepProcessor.hh.

  {
    return fPhysIntLength;
  }

Here is the caller graph for this function:

size_t G4ITStepProcessor::GetPostStepAtTimeDoItProcTriggered ( ) const

inline

Definition at line 256 of file G4ITStepProcessor.hh.

  {
    return fPostStepAtTimeDoItProcTriggered;
  }

size_t G4ITStepProcessor::GetPostStepDoItProcTriggered ( ) const

inline

Definition at line 261 of file G4ITStepProcessor.hh.

  {
    return fPostStepDoItProcTriggered;
  }

Here is the caller graph for this function:

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:

Here is the caller graph for this function:

const G4ITStepProcessorState* G4ITStepProcessor::GetProcessorState ( ) const

inline

Definition at line 271 of file G4ITStepProcessor.hh.

  {
    return fpState;
  }

Here is the caller graph for this function:

G4TrackVector* G4ITStepProcessor::GetSecondaries ( ) const

inline

Definition at line 180 of file G4ITStepProcessor.hh.

  {
    return fpSecondary;
  }

Here is the caller graph for this function:

G4Step* G4ITStepProcessor::GetStep ( )

inline

Definition at line 167 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

Here is the caller graph for this function:

const G4Step* G4ITStepProcessor::GetStep ( ) const

inline

Definition at line 171 of file G4ITStepProcessor.hh.

  {
    return fpStep;
  }

G4Track* G4ITStepProcessor::GetTrack ( )

inline

Definition at line 163 of file G4ITStepProcessor.hh.

  {
    return fpTrack;
  }

Here is the caller graph for this function:

const G4Track * G4ITStepProcessor::GetTrack ( ) const

inline

Definition at line 435 of file G4ITStepProcessor.hh.

{
  return fpTrack;
}

G4ITTrackingManager* G4ITStepProcessor::GetTrackingManager ( )

inline

Definition at line 188 of file G4ITStepProcessor.hh.

  {
    return fpTrackingManager;
  }

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:

Here is the caller graph for this function:

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:

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:

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

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++){
}

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

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

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

void G4ITStepProcessor::PrepareLeadingTracks

(

)

Definition at line 274 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.PrepareLeadingTracks();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

void G4ITStepProcessor::ResetLeadingTracks

(

)

Definition at line 267 of file G4ITStepProcessor.cc.

{
  fLeadingTracks.Reset();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITStepProcessor::ResetSecondaries ( )

protected

Definition at line 531 of file G4ITStepProcessor.cc.

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

Here is the caller graph for this function:

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:

Here is the caller graph for this function:

void G4ITStepProcessor::SetNavigator ( G4ITNavigator *  value )

inlineprotected

Definition at line 451 of file G4ITStepProcessor.hh.

{
  fpNavigator = value;
}

Here is the caller graph for this function:

void G4ITStepProcessor::SetPreviousStepTime ( G4double  previousTimeStep )

inline

Definition at line 428 of file G4ITStepProcessor.hh.

{
  fPreviousTimeStep = previousTimeStep;
}

Here is the caller graph for this function:

void G4ITStepProcessor::SetStep ( G4Step *  val )

inline

Definition at line 175 of file G4ITStepProcessor.hh.

  {
    fpStep = val;
  }

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:

Here is the caller graph for this function:

void G4ITStepProcessor::SetTrackingManager ( G4ITTrackingManager *  trackMan )

inline

Definition at line 184 of file G4ITStepProcessor.hh.

  {
    fpTrackingManager = trackMan;
  }

Here is the caller graph for this function:

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:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

friend class G4Scheduler

friend

Definition at line 156 of file G4ITStepProcessor.hh.

---

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

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