G4StackManager Class Reference

#include <G4StackManager.hh>

Public Member Functions
void	clear ()
void	ClearPostponeStack ()
void	ClearUrgentStack ()
void	ClearWaitingStack (G4int i=0)
	G4StackManager ()
G4int	GetNPostponedTrack () const
G4int	GetNTotalTrack () const
G4int	GetNUrgentTrack () const
G4int	GetNWaitingTrack (G4int i=0) const
G4bool	operator!= (const G4StackManager &) const =delete
const G4StackManager &	operator= (const G4StackManager &)=delete
G4bool	operator== (const G4StackManager &) const =delete
G4Track *	PopNextTrack (G4VTrajectory **newTrajectory)
G4int	PrepareNewEvent ()
G4int	PushOneTrack (G4Track *newTrack, G4VTrajectory *newTrajectory=nullptr)
void	ReClassify ()
void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)
void	SetUserStackingAction (G4UserStackingAction *value)
void	SetVerboseLevel (G4int const value)
void	TransferOneStackedTrack (G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
void	TransferStackedTracks (G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
	~G4StackManager ()

Private Member Functions
G4ClassificationOfNewTrack	DefaultClassification (G4Track *aTrack)

Private Attributes
std::vector< G4TrackStack * >	additionalWaitingStacks
G4int	numberOfAdditionalWaitingStacks = 0
G4TrackStack *	postponeStack = nullptr
G4StackingMessenger *	theMessenger = nullptr
G4TrackStack *	urgentStack = nullptr
G4UserStackingAction *	userStackingAction = nullptr
G4int	verboseLevel = 0
G4TrackStack *	waitingStack = nullptr

Detailed Description

Definition at line 61 of file G4StackManager.hh.

Constructor & Destructor Documentation

G4StackManager()

G4StackManager::G4StackManager

(

)

Definition at line 45 of file G4StackManager.cc.

{
  theMessenger = new G4StackingMessenger(this);
#ifdef G4_USESMARTSTACK
  urgentStack = new G4SmartTrackStack;
  // G4cout << "+++ G4StackManager uses G4SmartTrackStack. +++" << G4endl;
#else
  urgentStack = new G4TrackStack(5000);
  // G4cout << "+++ G4StackManager uses ordinary G4TrackStack. +++" << G4endl;
#endif
  waitingStack = new G4TrackStack(1000);
  postponeStack = new G4TrackStack(1000);
}

References postponeStack, theMessenger, urgentStack, and waitingStack.

~G4StackManager()

G4StackManager::~G4StackManager

(

)

Definition at line 59 of file G4StackManager.cc.

{
  if(userStackingAction) { delete userStackingAction; }
 
#ifdef G4VERBOSE
  if(verboseLevel>0)
  {
    G4cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << G4endl;
    G4cout << " Maximum number of tracks in the urgent stack : " << urgentStack->GetMaxNTrack() << G4endl;
    G4cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << G4endl;
  }
#endif
  delete urgentStack;
  delete waitingStack;
  delete postponeStack;
  delete theMessenger;
  if(numberOfAdditionalWaitingStacks>0)
  {
    for(G4int i=0; i<numberOfAdditionalWaitingStacks; ++i)
    {
      delete additionalWaitingStacks[i];
    }
  }
}

References additionalWaitingStacks, G4cout, G4endl, G4TrackStack::GetMaxNTrack(), numberOfAdditionalWaitingStacks, postponeStack, theMessenger, urgentStack, userStackingAction, verboseLevel, and waitingStack.

Member Function Documentation

clear()

void G4StackManager::clear

(

)

Definition at line 547 of file G4StackManager.cc.

{
  ClearUrgentStack();
  ClearWaitingStack();
  for(G4int i=1; i<=numberOfAdditionalWaitingStacks; ++i)
  {
    ClearWaitingStack(i);
  }
}

References ClearUrgentStack(), ClearWaitingStack(), and numberOfAdditionalWaitingStacks.

Referenced by G4EventManager::AbortCurrentEvent(), and export_G4StackManager().

ClearPostponeStack()

void G4StackManager::ClearPostponeStack

(

)

Definition at line 577 of file G4StackManager.cc.

{
  postponeStack->clearAndDestroy();
}

References G4TrackStack::clearAndDestroy(), and postponeStack.

Referenced by export_G4StackManager(), and G4StackingMessenger::SetNewValue().

ClearUrgentStack()

void G4StackManager::ClearUrgentStack

(

)

Definition at line 557 of file G4StackManager.cc.

{
  urgentStack->clearAndDestroy();
}

References G4TrackStack::clearAndDestroy(), and urgentStack.

Referenced by clear(), export_G4StackManager(), and G4StackingMessenger::SetNewValue().

ClearWaitingStack()

void G4StackManager::ClearWaitingStack

(

G4int

i = 0

)

Definition at line 562 of file G4StackManager.cc.

{
  if(i==0)
  {
    waitingStack->clearAndDestroy();
  }
  else
  {
    if(i<=numberOfAdditionalWaitingStacks)
    {
      additionalWaitingStacks[i-1]->clearAndDestroy();
    }
  }
}

References additionalWaitingStacks, G4TrackStack::clearAndDestroy(), numberOfAdditionalWaitingStacks, and waitingStack.

Referenced by clear(), export_G4StackManager(), and G4StackingMessenger::SetNewValue().

DefaultClassification()

G4ClassificationOfNewTrack G4StackManager::DefaultClassification ( G4Track *  aTrack )

private

Definition at line 634 of file G4StackManager.cc.

{
  G4ClassificationOfNewTrack classification = fUrgent;
  if( aTrack->GetTrackStatus() == fPostponeToNextEvent )
  {
    classification = fPostpone;
  }
  return classification;
}

References fPostpone, fPostponeToNextEvent, fUrgent, and G4Track::GetTrackStatus().

Referenced by PrepareNewEvent(), and PushOneTrack().

GetNPostponedTrack()

G4int G4StackManager::GetNPostponedTrack

(

)

const

Definition at line 615 of file G4StackManager.cc.

{
  return postponeStack->GetNTrack();
}

References G4TrackStack::GetNTrack(), and postponeStack.

Referenced by PrepareNewEvent(), and G4StackingMessenger::SetNewValue().

GetNTotalTrack()

G4int G4StackManager::GetNTotalTrack

(

)

const

Definition at line 582 of file G4StackManager.cc.

{
  G4int n = urgentStack->GetNTrack()
          + waitingStack->GetNTrack()
          + postponeStack->GetNTrack();
  for(G4int i=1; i<=numberOfAdditionalWaitingStacks; ++i)
  {
    n += additionalWaitingStacks[i-1]->GetNTrack();
  }
  return n;
}

References additionalWaitingStacks, G4TrackStack::GetNTrack(), CLHEP::detail::n, numberOfAdditionalWaitingStacks, postponeStack, urgentStack, and waitingStack.

Referenced by G4EventManager::DoProcessing(), and export_G4StackManager().

GetNUrgentTrack()

G4int G4StackManager::GetNUrgentTrack

(

)

const

Definition at line 594 of file G4StackManager.cc.

{
  return urgentStack->GetNTrack();
}

References G4TrackStack::GetNTrack(), and urgentStack.

Referenced by G4EventManager::DoProcessing(), export_G4StackManager(), PopNextTrack(), PushOneTrack(), ReClassify(), and G4StackingMessenger::SetNewValue().

GetNWaitingTrack()

G4int G4StackManager::GetNWaitingTrack

(

G4int

i = 0

)

const

Definition at line 599 of file G4StackManager.cc.

{
  if(i==0)
  {
    return waitingStack->GetNTrack();
  }
  else
  {
    if(i<=numberOfAdditionalWaitingStacks)
    {
      return additionalWaitingStacks[i-1]->GetNTrack();
    }
  }
  return 0;
}

References additionalWaitingStacks, G4TrackStack::GetNTrack(), numberOfAdditionalWaitingStacks, and waitingStack.

Referenced by export_G4StackManager(), PopNextTrack(), and G4StackingMessenger::SetNewValue().

operator!=()

G4bool G4StackManager::operator!= ( const G4StackManager &  ) const

delete

operator=()

const G4StackManager & G4StackManager::operator= ( const G4StackManager &  )

delete

operator==()

G4bool G4StackManager::operator== ( const G4StackManager &  ) const

delete

PopNextTrack()

G4Track * G4StackManager::PopNextTrack

(

G4VTrajectory **

newTrajectory

)

Definition at line 169 of file G4StackManager.cc.

{
#ifdef G4VERBOSE
  if( verboseLevel > 1 )
  {
    G4cout << "### pop requested out of " 
           << GetNUrgentTrack() << " stacked tracks." << G4endl;
  }
#endif
 
  while( GetNUrgentTrack() == 0 )
  {
#ifdef G4VERBOSE
    if( verboseLevel > 1 )
    {
      G4cout << "### " << GetNWaitingTrack()
             << " waiting tracks are re-classified to" << G4endl;
    }
#endif
    waitingStack->TransferTo(urgentStack);
    if(numberOfAdditionalWaitingStacks>0)
    {
      for(G4int i=0; i<numberOfAdditionalWaitingStacks; ++i)
      {
        if(i==0)
        {
          additionalWaitingStacks[0]->TransferTo(waitingStack);
        }
        else
        {
          additionalWaitingStacks[i]->TransferTo(additionalWaitingStacks[i-1]);
        }
      }
    }
    if(userStackingAction != nullptr)
    {
      userStackingAction->NewStage();
    }
 
#ifdef G4VERBOSE
    if( verboseLevel > 1 )
      G4cout << "     " << GetNUrgentTrack()
             << " urgent tracks and " << GetNWaitingTrack()
             << " waiting tracks." << G4endl;
#endif
    if( ( GetNUrgentTrack()==0 ) && ( GetNWaitingTrack()==0 ) )
      return 0;
  }
 
  G4StackedTrack selectedStackedTrack = urgentStack->PopFromStack();
  G4Track * selectedTrack = selectedStackedTrack.GetTrack();
  *newTrajectory = selectedStackedTrack.GetTrajectory();
 
#ifdef G4VERBOSE
  if( verboseLevel > 2 )
  {
    G4cout << "Selected G4StackedTrack : " << &selectedStackedTrack
           << " with G4Track " << selectedStackedTrack.GetTrack()
           << " (trackID " << selectedStackedTrack.GetTrack()->GetTrackID()
           << ", parentID " << selectedStackedTrack.GetTrack()->GetParentID()
           << ")" << G4endl;
  }
#endif
 
  return selectedTrack;
}

References additionalWaitingStacks, G4cout, G4endl, GetNUrgentTrack(), GetNWaitingTrack(), G4Track::GetParentID(), G4StackedTrack::GetTrack(), G4Track::GetTrackID(), G4StackedTrack::GetTrajectory(), G4UserStackingAction::NewStage(), numberOfAdditionalWaitingStacks, G4TrackStack::PopFromStack(), G4TrackStack::TransferTo(), urgentStack, userStackingAction, verboseLevel, and waitingStack.

Referenced by G4EventManager::DoProcessing().

PrepareNewEvent()

G4int G4StackManager::PrepareNewEvent

(

)

Definition at line 283 of file G4StackManager.cc.

{
  if(userStackingAction)
  {
    userStackingAction->PrepareNewEvent();
  }
  
  // Set the urgentStack in a defined state. Not doing it would
  // affect reproducibility
  //
  urgentStack->clearAndDestroy();
  
  G4int n_passedFromPrevious = 0;
  
  if( GetNPostponedTrack() > 0 )
  {
#ifdef G4VERBOSE
    if( verboseLevel > 1 )
    {
      G4cout << GetNPostponedTrack()
             << " postponed tracked are now shifted to the stack." << G4endl;
    }
#endif
    
    G4StackedTrack aStackedTrack;
    G4TrackStack   tmpStack;
    
    postponeStack->TransferTo(&tmpStack);
    
    while( tmpStack.GetNTrack() > 0 )
    {
      aStackedTrack=tmpStack.PopFromStack();
      G4Track* aTrack = aStackedTrack.GetTrack();
      aTrack->SetParentID(-1);
      G4ClassificationOfNewTrack classification;
      if(userStackingAction)
      {
        classification = userStackingAction->ClassifyNewTrack( aTrack );
      }
      else
      {
        classification = DefaultClassification( aTrack );
      }
      
      if(classification==fKill)
      {
        delete aTrack;
        delete aStackedTrack.GetTrajectory();
      }
      else
      {
        aTrack->SetTrackID(-(++n_passedFromPrevious));
        switch (classification)
        {
          case fUrgent:
            urgentStack->PushToStack( aStackedTrack );
            break;
          case fWaiting:
            waitingStack->PushToStack( aStackedTrack );
            break;
          case fPostpone:
            postponeStack->PushToStack( aStackedTrack );
            break;
          default:
            G4int i = classification - 10;
            if(i<1||i>numberOfAdditionalWaitingStacks)
            {
              G4ExceptionDescription ED;
              ED << "invalid classification " << classification << G4endl;
              G4Exception("G4StackManager::PrepareNewEvent", "Event0053",
                          FatalException, ED);
            }
            else
            {
              additionalWaitingStacks[i-1]->PushToStack( aStackedTrack );
            }
            break;
        }
      }
    }
  }
  return n_passedFromPrevious;
}

References additionalWaitingStacks, G4UserStackingAction::ClassifyNewTrack(), G4TrackStack::clearAndDestroy(), DefaultClassification(), FatalException, fKill, fPostpone, fUrgent, fWaiting, G4cout, G4endl, G4Exception(), GetNPostponedTrack(), G4TrackStack::GetNTrack(), G4StackedTrack::GetTrack(), G4StackedTrack::GetTrajectory(), numberOfAdditionalWaitingStacks, G4TrackStack::PopFromStack(), postponeStack, G4UserStackingAction::PrepareNewEvent(), G4TrackStack::PushToStack(), G4Track::SetParentID(), G4Track::SetTrackID(), G4TrackStack::TransferTo(), urgentStack, userStackingAction, verboseLevel, and waitingStack.

Referenced by G4EventManager::DoProcessing().

PushOneTrack()

G4int G4StackManager::PushOneTrack	(	G4Track *	newTrack,
		G4VTrajectory *	newTrajectory = nullptr
	)

Definition at line 84 of file G4StackManager.cc.

{
  const G4ParticleDefinition* pd = newTrack->GetParticleDefinition();
  if(pd->GetParticleDefinitionID() < 0)
  {
    G4ExceptionDescription ED;
    ED << "A track without proper process manager is pushed \
           into the track stack.\n"
       << " Particle name : " << pd->GetParticleName() << " -- ";
    if(newTrack->GetParentID()<0)
    {
      ED << "created by a primary particle generator.";
    }
    else
    { 
      const G4VProcess* vp = newTrack->GetCreatorProcess();
      if(vp)
      {
        ED << "created by " << vp->GetProcessName() << ".";
      }
      else
      {
        ED << "creaded by unknown process.";
      }
    }
    G4Exception("G4StackManager::PushOneTrack","Event10051",
                 FatalException,ED);
    delete newTrack;
    return GetNUrgentTrack();
  }
    
  G4ClassificationOfNewTrack classification = DefaultClassification( newTrack );
  if(userStackingAction != nullptr) 
  {
    classification = userStackingAction->ClassifyNewTrack( newTrack );
  }
 
  if(classification==fKill)   // delete newTrack without stacking
  {
#ifdef G4VERBOSE
    if( verboseLevel > 1 )
    {
      G4cout << "   ---> G4Track " << newTrack << " (trackID "
             << newTrack->GetTrackID() << ", parentID "
             << newTrack->GetParentID() << ") is not to be stored." << G4endl;
    }
#endif
    delete newTrack;
    delete newTrajectory;
  }
  else
  {
    G4StackedTrack newStackedTrack( newTrack, newTrajectory );
    switch (classification)
    {
      case fUrgent:
        urgentStack->PushToStack( newStackedTrack );
        break;
      case fWaiting:
        waitingStack->PushToStack( newStackedTrack );
        break;
      case fPostpone:
        postponeStack->PushToStack( newStackedTrack );
        break;
      default:
        G4int i = classification - 10;
        if(i<1 || i>numberOfAdditionalWaitingStacks)
        {
          G4ExceptionDescription ED;
          ED << "invalid classification " << classification << G4endl;
          G4Exception("G4StackManager::PushOneTrack", "Event0051",
                      FatalException,ED);
        }
        else
        {
          additionalWaitingStacks[i-1]->PushToStack( newStackedTrack );
        }
        break;
    }
  }
  return GetNUrgentTrack();
}

References additionalWaitingStacks, G4UserStackingAction::ClassifyNewTrack(), DefaultClassification(), FatalException, fKill, fPostpone, fUrgent, fWaiting, G4cout, G4endl, G4Exception(), G4Track::GetCreatorProcess(), GetNUrgentTrack(), G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4Track::GetTrackID(), numberOfAdditionalWaitingStacks, postponeStack, G4TrackStack::PushToStack(), urgentStack, userStackingAction, verboseLevel, and waitingStack.

Referenced by G4EventManager::DoProcessing(), and G4EventManager::StackTracks().

ReClassify()

void G4StackManager::ReClassify

(

)

Definition at line 236 of file G4StackManager.cc.

{
  G4StackedTrack aStackedTrack;
  G4TrackStack tmpStack;
  
  if( userStackingAction == nullptr ) return;
  if( GetNUrgentTrack() == 0 ) return;
  
  urgentStack->TransferTo(&tmpStack);
  while( tmpStack.GetNTrack() > 0 )
  {
    aStackedTrack=tmpStack.PopFromStack();
    G4ClassificationOfNewTrack classification =
    userStackingAction->ClassifyNewTrack( aStackedTrack.GetTrack() );
    switch (classification)
    {
      case fKill:
        delete aStackedTrack.GetTrack();
        delete aStackedTrack.GetTrajectory();
        break;
      case fUrgent:
        urgentStack->PushToStack( aStackedTrack );
        break;
      case fWaiting:
        waitingStack->PushToStack( aStackedTrack );
        break;
      case fPostpone:
        postponeStack->PushToStack( aStackedTrack );
        break;
      default:
        G4int i = classification - 10;
        if(i<1||i>numberOfAdditionalWaitingStacks)
        {
          G4ExceptionDescription ED;
          ED << "invalid classification " << classification << G4endl;
          G4Exception("G4StackManager::ReClassify", "Event0052",
                      FatalException, ED);
        }
        else
        {
          additionalWaitingStacks[i-1]->PushToStack( aStackedTrack );
        }
        break;
    }
  }
}

References additionalWaitingStacks, G4UserStackingAction::ClassifyNewTrack(), FatalException, fKill, fPostpone, fUrgent, fWaiting, G4endl, G4Exception(), G4TrackStack::GetNTrack(), GetNUrgentTrack(), G4StackedTrack::GetTrack(), G4StackedTrack::GetTrajectory(), numberOfAdditionalWaitingStacks, G4TrackStack::PopFromStack(), postponeStack, G4TrackStack::PushToStack(), G4TrackStack::TransferTo(), urgentStack, userStackingAction, and waitingStack.

Referenced by export_G4StackManager(), and G4AdjointStackingAction::NewStage().

SetNumberOfAdditionalWaitingStacks()

void G4StackManager::SetNumberOfAdditionalWaitingStacks

(

G4int

iAdd

)

Definition at line 367 of file G4StackManager.cc.

{
  if(iAdd > numberOfAdditionalWaitingStacks)
  {
    for(G4int i=numberOfAdditionalWaitingStacks; i<iAdd; ++i)
    {
      G4TrackStack* newStack = new G4TrackStack;
      additionalWaitingStacks.push_back(newStack);
    }
    numberOfAdditionalWaitingStacks = iAdd;
  }
  else if (iAdd < numberOfAdditionalWaitingStacks)
  {
    for(G4int i=numberOfAdditionalWaitingStacks; i>iAdd; --i)
    {
      delete additionalWaitingStacks[i];
    }
  }
}

References additionalWaitingStacks, and numberOfAdditionalWaitingStacks.

Referenced by G4EventManager::SetNumberOfAdditionalWaitingStacks().

SetUserStackingAction()

void G4StackManager::SetUserStackingAction

(

G4UserStackingAction *

value

)

Definition at line 625 of file G4StackManager.cc.

{
  userStackingAction = value;
  if(userStackingAction)
  {
    userStackingAction->SetStackManager(this);
  }
}

References G4UserStackingAction::SetStackManager(), and userStackingAction.

Referenced by G4EventManager::SetUserAction().

SetVerboseLevel()

void G4StackManager::SetVerboseLevel

(

G4int const

value

)

Definition at line 620 of file G4StackManager.cc.

{
  verboseLevel = value;
}

References verboseLevel.

Referenced by export_G4StackManager(), G4StackingMessenger::SetNewValue(), and G4EventManager::SetVerboseLevel().

TransferOneStackedTrack()

void G4StackManager::TransferOneStackedTrack	(	G4ClassificationOfNewTrack	origin,
		G4ClassificationOfNewTrack	destination
	)

Definition at line 466 of file G4StackManager.cc.

{
  if(origin==destination) return;
  if(origin==fKill) return;
  G4TrackStack* originStack = nullptr;
  switch(origin)
  {
    case fUrgent:
      originStack = nullptr;
      break;
    case fWaiting:
      originStack = waitingStack;
      break;
    case fPostpone:
      originStack = postponeStack;
      break;
    default:
      G4int i = origin - 10;
      if(i<=numberOfAdditionalWaitingStacks)
      {
        originStack = additionalWaitingStacks[i-1];
      }
      break;
  }
  
  G4StackedTrack aStackedTrack;
  if(destination==fKill)
  {
    if( originStack != nullptr && originStack->GetNTrack() )
    {
      aStackedTrack = originStack->PopFromStack();
      delete aStackedTrack.GetTrack();
      delete aStackedTrack.GetTrajectory();
    }
    else if (urgentStack->GetNTrack() )
    {
      aStackedTrack = urgentStack->PopFromStack();
      delete aStackedTrack.GetTrack();
      delete aStackedTrack.GetTrajectory();
    }
  }
  else
  {
    G4TrackStack* targetStack = nullptr;
    switch(destination)
    {
      case fUrgent:
        targetStack = nullptr;
        break;
      case fWaiting:
        targetStack = waitingStack;
        break;
      case fPostpone:
        targetStack = postponeStack;
        break;
      default:
        G4int i = destination - 10;
        if(i<=numberOfAdditionalWaitingStacks)
        {
          targetStack = additionalWaitingStacks[i-1];
        }
        break;
    }
    if(originStack && originStack->GetNTrack())
    {
      aStackedTrack = originStack->PopFromStack();
      if(targetStack) { targetStack->PushToStack(aStackedTrack); }
      else            { urgentStack->PushToStack(aStackedTrack); }
    }
    else if(urgentStack->GetNTrack())
    {
      aStackedTrack = urgentStack->PopFromStack();
      if(targetStack) { targetStack->PushToStack(aStackedTrack); }
      else            { urgentStack->PushToStack(aStackedTrack); }
    }
  }
  return;
}

References additionalWaitingStacks, fKill, fPostpone, fUrgent, fWaiting, G4TrackStack::GetNTrack(), G4StackedTrack::GetTrack(), G4StackedTrack::GetTrajectory(), numberOfAdditionalWaitingStacks, G4TrackStack::PopFromStack(), postponeStack, G4TrackStack::PushToStack(), urgentStack, and waitingStack.

TransferStackedTracks()

void G4StackManager::TransferStackedTracks	(	G4ClassificationOfNewTrack	origin,
		G4ClassificationOfNewTrack	destination
	)

Definition at line 387 of file G4StackManager.cc.

{
  if(origin==destination) return;
  if(origin==fKill) return;
  G4TrackStack* originStack = nullptr;
  switch(origin)
  {
    case fUrgent:
      originStack = nullptr;
      break;
    case fWaiting:
      originStack = waitingStack;
      break;
    case fPostpone:
      originStack = postponeStack;
      break;
    default:
      G4int i = origin - 10;
      if(i<=numberOfAdditionalWaitingStacks)
      {
        originStack = additionalWaitingStacks[i-1];
      }
      break;
  }
  
  if(destination==fKill)
  {
    if(originStack != nullptr)
    {
      originStack->clearAndDestroy();
    }
    else
    {
      urgentStack->clearAndDestroy();
    }
  }
  else
  {
    G4TrackStack* targetStack = nullptr;
    switch(destination)
    {
      case fUrgent:
        targetStack = nullptr;
        break;
      case fWaiting:
        targetStack = waitingStack;
        break;
      case fPostpone:
        targetStack = postponeStack;
        break;
      default:
        G4int i = destination - 10;
        if(i<=numberOfAdditionalWaitingStacks)
        {
          targetStack = additionalWaitingStacks[i-1];
        }
        break;
    }
    if(originStack != nullptr)
    {
      if(targetStack != nullptr)
      {
        originStack->TransferTo(targetStack);
      }
      else
      {
        originStack->TransferTo(urgentStack);
      }
    }
    else
    {
      urgentStack->TransferTo(targetStack);
    }
  }
  return;
}

References additionalWaitingStacks, G4TrackStack::clearAndDestroy(), fKill, fPostpone, fUrgent, fWaiting, numberOfAdditionalWaitingStacks, postponeStack, G4TrackStack::TransferTo(), urgentStack, and waitingStack.

Field Documentation

additionalWaitingStacks

std::vector<G4TrackStack*> G4StackManager::additionalWaitingStacks

private

Definition at line 137 of file G4StackManager.hh.

Referenced by ClearWaitingStack(), GetNTotalTrack(), GetNWaitingTrack(), PopNextTrack(), PrepareNewEvent(), PushOneTrack(), ReClassify(), SetNumberOfAdditionalWaitingStacks(), TransferOneStackedTrack(), TransferStackedTracks(), and ~G4StackManager().

numberOfAdditionalWaitingStacks

G4int G4StackManager::numberOfAdditionalWaitingStacks = 0

private

Definition at line 138 of file G4StackManager.hh.

Referenced by clear(), ClearWaitingStack(), GetNTotalTrack(), GetNWaitingTrack(), PopNextTrack(), PrepareNewEvent(), PushOneTrack(), ReClassify(), SetNumberOfAdditionalWaitingStacks(), TransferOneStackedTrack(), TransferStackedTracks(), and ~G4StackManager().

postponeStack

G4TrackStack* G4StackManager::postponeStack = nullptr

private

Definition at line 135 of file G4StackManager.hh.

Referenced by ClearPostponeStack(), G4StackManager(), GetNPostponedTrack(), GetNTotalTrack(), PrepareNewEvent(), PushOneTrack(), ReClassify(), TransferOneStackedTrack(), TransferStackedTracks(), and ~G4StackManager().

theMessenger

G4StackingMessenger* G4StackManager::theMessenger = nullptr

private

Definition at line 136 of file G4StackManager.hh.

Referenced by G4StackManager(), and ~G4StackManager().

urgentStack

G4TrackStack* G4StackManager::urgentStack = nullptr

private

Definition at line 132 of file G4StackManager.hh.

Referenced by ClearUrgentStack(), G4StackManager(), GetNTotalTrack(), GetNUrgentTrack(), PopNextTrack(), PrepareNewEvent(), PushOneTrack(), ReClassify(), TransferOneStackedTrack(), TransferStackedTracks(), and ~G4StackManager().

userStackingAction

G4UserStackingAction* G4StackManager::userStackingAction = nullptr

private

Definition at line 127 of file G4StackManager.hh.

Referenced by PopNextTrack(), PrepareNewEvent(), PushOneTrack(), ReClassify(), SetUserStackingAction(), and ~G4StackManager().

verboseLevel

G4int G4StackManager::verboseLevel = 0

private

Definition at line 128 of file G4StackManager.hh.

Referenced by PopNextTrack(), PrepareNewEvent(), PushOneTrack(), SetVerboseLevel(), and ~G4StackManager().

waitingStack

G4TrackStack* G4StackManager::waitingStack = nullptr

private

Definition at line 134 of file G4StackManager.hh.

Referenced by ClearWaitingStack(), G4StackManager(), GetNTotalTrack(), GetNWaitingTrack(), PopNextTrack(), PrepareNewEvent(), PushOneTrack(), ReClassify(), TransferOneStackedTrack(), TransferStackedTracks(), and ~G4StackManager().

---

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

• source/event/include/G4StackManager.hh
• source/event/src/G4StackManager.cc