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 ()
void	ReClassify ()
void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)
void	TransferStackedTracks (G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
void	TransferOneStackedTrack (G4ClassificationOfNewTrack origin, G4ClassificationOfNewTrack destination)
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 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);
}

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

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

Referenced by G4EventManager::AbortCurrentEvent().

ClearPostponeStack()

void G4StackManager::ClearPostponeStack

(

)

Definition at line 577 of file G4StackManager.cc.

{
  postponeStack->clearAndDestroy();
}

Referenced by G4StackingMessenger::SetNewValue().

ClearUrgentStack()

void G4StackManager::ClearUrgentStack

(

)

Definition at line 557 of file G4StackManager.cc.

{
  urgentStack->clearAndDestroy();
}

Referenced by clear(), 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();
    }
  }
}

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

GetNPostponedTrack()

G4int G4StackManager::GetNPostponedTrack

(

)

const

Definition at line 615 of file G4StackManager.cc.

{
  return postponeStack->GetNTrack();
}

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

GetNUrgentTrack()

G4int G4StackManager::GetNUrgentTrack

(

)

const

Definition at line 594 of file G4StackManager.cc.

{
  return urgentStack->GetNTrack();
}

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

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

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

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

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

Referenced by 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];
    }
  }
}

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

Referenced by G4EventManager::SetUserAction().

SetVerboseLevel()

void G4StackManager::SetVerboseLevel

(

G4int const

value

)

Definition at line 620 of file G4StackManager.cc.

{
  verboseLevel = value;
}

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

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

---

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

• G4StackManager.hh
• G4StackManager.cc