G4StackManager Class Reference

#include <G4StackManager.hh>

Public Member Functions
	G4StackManager ()
	~G4StackManager ()
const G4StackManager &	operator= (const G4StackManager &)=delete
G4bool	operator== (const G4StackManager &) const =delete
G4bool	operator!= (const G4StackManager &) const =delete
G4int	PushOneTrack (G4Track *newTrack, G4VTrajectory *newTrajectory=nullptr)
G4Track *	PopNextTrack (G4VTrajectory **newTrajectory)
G4int	PrepareNewEvent (G4Event *currentEvent)
void	ReClassify ()
void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)
void	TransferStackedTracks (G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
void	TransferOneStackedTrack (G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
void	RegisterSubEventType (G4int ty, G4int maxEnt)
void	SetDefaultClassification (G4TrackStatus, G4ClassificationOfNewTrack, G4ExceptionSeverity es=G4ExceptionSeverity::IgnoreTheIssue)
void	SetDefaultClassification (const G4ParticleDefinition *, G4ClassificationOfNewTrack, G4ExceptionSeverity es=G4ExceptionSeverity::IgnoreTheIssue)
G4ClassificationOfNewTrack	GetDefaultClassification ()
void	ReleaseSubEvent (G4int ty)
std::size_t	GetNSubEventTypes ()
G4int	GetSubEventType (std::size_t i)
void	clear ()
void	ClearUrgentStack ()
void	ClearWaitingStack (G4int i=0)
void	ClearPostponeStack ()
G4int	GetNTotalTrack () const
G4int	GetNUrgentTrack () const
G4int	GetNWaitingTrack (G4int i=0) const
G4int	GetNPostponedTrack () const
void	SetVerboseLevel (G4int const value)
void	SetUserStackingAction (G4UserStackingAction *value)

Detailed Description

Definition at line 69 of file G4StackManager.hh.

Constructor & Destructor Documentation

G4StackManager()

G4StackManager::G4StackManager

(

)

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

~G4StackManager()

G4StackManager::~G4StackManager

(

)

Definition at line 62 of file G4StackManager.cc.

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

Member Function Documentation

clear()

void G4StackManager::clear

(

)

Definition at line 617 of file G4StackManager.cc.

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

Referenced by G4EventManager::AbortCurrentEvent().

ClearPostponeStack()

void G4StackManager::ClearPostponeStack

(

)

Definition at line 647 of file G4StackManager.cc.

{
  postponeStack->clearAndDestroy();
}

Referenced by G4StackingMessenger::SetNewValue().

ClearUrgentStack()

void G4StackManager::ClearUrgentStack

(

)

Definition at line 627 of file G4StackManager.cc.

{
  urgentStack->clearAndDestroy();
}

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

ClearWaitingStack()

void G4StackManager::ClearWaitingStack

(

G4int

i = 0

)

Definition at line 632 of file G4StackManager.cc.

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

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

GetDefaultClassification()

G4ClassificationOfNewTrack G4StackManager::GetDefaultClassification ( )

inline

Definition at line 133 of file G4StackManager.hh.

    { return fDefaultClassification; }

GetNPostponedTrack()

G4int G4StackManager::GetNPostponedTrack

(

)

const

Definition at line 684 of file G4StackManager.cc.

{
  return (G4int)postponeStack->GetNTrack();
}

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

GetNSubEventTypes()

std::size_t G4StackManager::GetNSubEventTypes ( )

inline

Definition at line 138 of file G4StackManager.hh.

    { return subEvtTypes.size(); }

GetNTotalTrack()

G4int G4StackManager::GetNTotalTrack

(

)

const

Definition at line 652 of file G4StackManager.cc.

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

GetNUrgentTrack()

G4int G4StackManager::GetNUrgentTrack

(

)

const

Definition at line 664 of file G4StackManager.cc.

{
  return (G4int)urgentStack->GetNTrack();
}

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

GetNWaitingTrack()

G4int G4StackManager::GetNWaitingTrack

(

G4int

i = 0

)

const

Definition at line 669 of file G4StackManager.cc.

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

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

GetSubEventType()

G4int G4StackManager::GetSubEventType ( std::size_t i )

inline

Definition at line 140 of file G4StackManager.hh.

    { return subEvtTypes[i]; }

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

PrepareNewEvent()

G4int G4StackManager::PrepareNewEvent

(

G4Event *

currentEvent

)

Definition at line 270 of file G4StackManager.cc.

{
  if(userStackingAction != nullptr)
  {
    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();
      DefineDefaultClassification( aTrack );
      G4ClassificationOfNewTrack classification = fDefaultClassification;
      if(userStackingAction!=nullptr)
      {
        classification = userStackingAction->ClassifyNewTrack( aTrack );
        if(classification != fDefaultClassification)
        {
          if(fExceptionSeverity!=G4ExceptionSeverity::IgnoreTheIssue)
          {
            G4ExceptionDescription ed;
            ed << "UserStackingAction has changed the track classification from "
               << fDefaultClassification << " to " << classification << ". ";
            G4Exception("G4StackManager::PushOneTrack","Event10052",
                        fExceptionSeverity,ed);
          }
        }
      }
      if(classification!=fKill)
      {
        aTrack->SetParentID(-1);
        aTrack->SetTrackID(-(++n_passedFromPrevious)); 
      }
      else if(aTrack->GetTrackStatus() == fSuspendAndWait && classification > 0)
      // to avoid this track sent to Waiting stack again
      { aTrack->SetTrackStatus( fSuspend ); }
 
      SortOut(aStackedTrack,classification);
    }
  }
 
  // Reset sub-event stacks for a new event
  for(auto& ses : subEvtStackMap)
  { ses.second->PrepareNewEvent(currentEvent); }
 
  return n_passedFromPrevious;
}

PushOneTrack()

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

Definition at line 87 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 != nullptr)
      {
        ED << "created by " << vp->GetProcessName() << ".";
      }
      else
      {
        ED << "creaded by unknown process.";
      }
    }
    G4Exception("G4StackManager::PushOneTrack","Event10051",
                 FatalException,ED);
    delete newTrack;
    return GetNUrgentTrack();
  }
    
  DefineDefaultClassification( newTrack );
  G4ClassificationOfNewTrack classification = fDefaultClassification;
  if(userStackingAction!=nullptr)
  {
    classification = userStackingAction->ClassifyNewTrack( newTrack );
    if(classification != fDefaultClassification)
    {
      if(fExceptionSeverity!=G4ExceptionSeverity::IgnoreTheIssue)
      {
        G4ExceptionDescription ed;
        ed << "UserStackingAction has changed the track classification from "
           << fDefaultClassification << " to " << classification << ". ";
        G4Exception("G4StackManager::PushOneTrack","Event10052",
                    fExceptionSeverity,ed);
      }
    }
  }
  if(newTrack->GetTrackStatus() == fSuspendAndWait && classification > 0)
  // to avoid this track sent to Waiting stack again
  { newTrack->SetTrackStatus( fSuspend ); }
 
#ifdef G4VERBOSE
  if( verboseLevel > 1 )
  {
    G4cout << "### Storing a track ("
           << newTrack->GetParticleDefinition()->GetParticleName()
           << ",trackID=" << newTrack->GetTrackID()
           << ",parentID=" << newTrack->GetParentID() << ") ";
    if(newTrack->GetParentID()==0)
    { G4cout << "created by a primary particle generator "; }
    else
    { 
      const G4VProcess* vp = newTrack->GetCreatorProcess();
      if(vp != nullptr)
      { G4cout << "created by " << vp->GetProcessName() << " "; }
      else
      { G4cout << "creaded by unknown process "; }
    }
    G4cout << "into stack #" << classification << G4endl;
  }
#endif
  G4StackedTrack newStackedTrack( newTrack, newTrajectory );
  SortOut(newStackedTrack,classification);
 
  return GetNUrgentTrack();
}

Referenced by G4EventManager::StackTracks().

ReClassify()

void G4StackManager::ReClassify

(

)

Definition at line 233 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();
    DefineDefaultClassification( aStackedTrack.GetTrack() );
    G4ClassificationOfNewTrack classification = fDefaultClassification;
    if(userStackingAction!=nullptr)
    {
      classification = userStackingAction->ClassifyNewTrack( aStackedTrack.GetTrack() );
      if(classification != fDefaultClassification)
      {
        if(fExceptionSeverity!=G4ExceptionSeverity::IgnoreTheIssue)
        {
          G4ExceptionDescription ed;
          ed << "UserStackingAction has changed the track classification from "
             << fDefaultClassification << " to " << classification << ". ";
          G4Exception("G4StackManager::PushOneTrack","Event10052",
                      fExceptionSeverity,ed);
        }
      }
    }
    if(aStackedTrack.GetTrack()->GetTrackStatus() == fSuspendAndWait && classification > 0)
    // to avoid this track sent to Waiting stack again
    { aStackedTrack.GetTrack()->SetTrackStatus( fSuspend ); }
 
    SortOut(aStackedTrack,classification);
  }
}

Referenced by G4AdjointStackingAction::NewStage().

RegisterSubEventType()

void G4StackManager::RegisterSubEventType	(	G4int	ty,
		G4int	maxEnt )

Definition at line 780 of file G4StackManager.cc.

{
  if(subEvtStackMap.find(ty)==subEvtStackMap.end())
  {
    subEvtStackMap[ty] = new G4SubEventTrackStack(ty,maxEnt);
    subEvtTypes.push_back(ty);
#ifdef G4VERBOSE
    subEvtStackMap[ty]->SetVerboseLevel(verboseLevel);
    if( verboseLevel > 0 )
    {
      G4cout << "   ---> New sub-event stack for sub-event type "
             << ty << " is created. Classification id for this stack is "
             << subEvtTypes.size() + 99 << "." << G4endl;
    }
  }
  else
  {
    if( verboseLevel > 1 )
    {
      G4cout << "   ---> Sub-event stack for sub-event type "
             << ty << " already registered." << G4endl;
    }
#endif  
  }
}

ReleaseSubEvent()

void G4StackManager::ReleaseSubEvent

(

G4int

ty

)

Definition at line 806 of file G4StackManager.cc.

{
  auto ses = subEvtStackMap.find(ty);
  if(ses==subEvtStackMap.end())
  {
    G4ExceptionDescription ED;
    ED << "Un-registered sub-event type " << ty << " requested.";
    G4Exception("G4StackManager::PopSubEvent", "SubEvt8001",
                 FatalException,ED);
    return; // NOLINT: Required to silence Coverity, which does not recognize G4Exception as exit point
  }
 
  ses->second->ReleaseSubEvent();
}

SetDefaultClassification() [1/2]

void G4StackManager::SetDefaultClassification	(	const G4ParticleDefinition *	pd,
		G4ClassificationOfNewTrack	val,
		G4ExceptionSeverity	es = G4ExceptionSeverity::IgnoreTheIssue )

Definition at line 757 of file G4StackManager.cc.

{
  auto pdm = defClassPartDef.find(pd);
  if(pdm==defClassPartDef.end())
  { defClassPartDef[pd] = std::pair(val,es); }
  else
  {
    if(pdm->second.first!=val)
    { // alternating default classification
      G4ExceptionDescription ed;
      ed << "Default classification for particle " << pd->GetParticleName()
         << " is changed from " << pdm->second.first << " to "
         << val << ".";
      G4Exception("G4StackManager::SetDefaultClassification",
                  "Event11052", JustWarning,ed);
      pdm->second.first = val;
    }
    // Change severity if needed.
    if(pdm->second.second>es) pdm->second.second = es;
  }
}

SetDefaultClassification() [2/2]

void G4StackManager::SetDefaultClassification	(	G4TrackStatus	ts,
		G4ClassificationOfNewTrack	val,
		G4ExceptionSeverity	es = G4ExceptionSeverity::IgnoreTheIssue )

Definition at line 734 of file G4StackManager.cc.

{
  auto tsm = defClassTrackStatus.find(ts);
  if(tsm==defClassTrackStatus.end())
  { defClassTrackStatus[ts] = std::pair(val,es); }
  else
  {
    if(tsm->second.first!=val)
    { // alternating default classification
      G4ExceptionDescription ed;
      ed << "Default classification for track status " << ts 
         << " is changed from " << tsm->second.first << " to "
         << val << ".";
      G4Exception("G4StackManager::SetDefaultClassification",
                  "Event11051",JustWarning,ed);
      tsm->second.first = val;
    }
    // Change severity if needed.
    if(tsm->second.second>es) tsm->second.second = es;
  }
}

SetNumberOfAdditionalWaitingStacks()

void G4StackManager::SetNumberOfAdditionalWaitingStacks

(

G4int

iAdd

)

Definition at line 409 of file G4StackManager.cc.

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

Referenced by G4RunManager::SetNumberOfAdditionalWaitingStacks().

SetUserStackingAction()

void G4StackManager::SetUserStackingAction

(

G4UserStackingAction *

value

)

Definition at line 696 of file G4StackManager.cc.

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

Referenced by G4EventManager::SetUserAction().

SetVerboseLevel()

void G4StackManager::SetVerboseLevel

(

G4int const

value

)

Definition at line 689 of file G4StackManager.cc.

{
  verboseLevel = value;
  for(auto& sets : subEvtStackMap)
  { sets.second->SetVerboseLevel(value); }
}

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

TransferOneStackedTrack()

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

Definition at line 522 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];
      }
      else
      {
        G4ExceptionDescription ED;
        ED << "Invalid origin stack ID " << origin;
        G4Exception("G4StackManager::TransferStackedTracks","Stack0911",
                    FatalException, ED);
      }
      break;
  }
  
  G4StackedTrack aStackedTrack;
  if(destination==fKill)
  {
    if( originStack != nullptr && (originStack->GetNTrack() != 0u) )
    {
      aStackedTrack = originStack->PopFromStack();
      delete aStackedTrack.GetTrack();
      delete aStackedTrack.GetTrajectory();
    }
    else if (urgentStack->GetNTrack() != 0u )
    {
      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];
        }
        else
        {
          G4ExceptionDescription ED;
          ED << "Invalid origin stack ID " << origin;
          G4Exception("G4StackManager::TransferStackedTracks","Stack0911",
                      FatalException, ED);
        }
        break;
    }
    if((originStack != nullptr) && (originStack->GetNTrack() != 0u))
    {
      aStackedTrack = originStack->PopFromStack();
      if(targetStack != nullptr) { targetStack->PushToStack(aStackedTrack); }
      else            { urgentStack->PushToStack(aStackedTrack); }
    }
    else if(urgentStack->GetNTrack() != 0u)
    {
      aStackedTrack = urgentStack->PopFromStack();
      if(targetStack != nullptr) { targetStack->PushToStack(aStackedTrack); }
      else            { urgentStack->PushToStack(aStackedTrack); }
    }
  }
  return;
}

TransferStackedTracks()

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

Definition at line 429 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];
      }
      else
      {
        G4ExceptionDescription ED;
        ED << "Invalid origin stack ID " << origin;
        G4Exception("G4StackManager::TransferStackedTracks","Stack0911",
                    FatalException, ED);
      }
      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];
        }
        else
        {
          G4ExceptionDescription ED;
          ED << "Invalid origin stack ID " << origin;
          G4Exception("G4StackManager::TransferStackedTracks","Stack0911",
                      FatalException, ED);
        }
        break;
    }
    if(originStack != nullptr)
    {
      if(targetStack != nullptr)
      {
        originStack->TransferTo(targetStack);
      }
      else
      {
        originStack->TransferTo(urgentStack);
      }
    }
    else
    {
      urgentStack->TransferTo(targetStack);
    }
  }
  return;
}

---

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

• G4StackManager.hh
• G4StackManager.cc