G4StackManager Class Reference

#include <G4StackManager.hh>

Public Member Functions
	G4StackManager ()
	~G4StackManager ()
G4int	PushOneTrack (G4Track *newTrack, G4VTrajectory *newTrajectory=0)
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 (int i=0)
void	ClearPostponeStack ()
G4int	GetNTotalTrack () const
G4int	GetNUrgentTrack () const
G4int	GetNWaitingTrack (int i=0) const
G4int	GetNPostponedTrack () const
void	SetVerboseLevel (G4int const value)
void	SetUserStackingAction (G4UserStackingAction *value)

Detailed Description

Definition at line 62 of file G4StackManager.hh.

Constructor & Destructor Documentation

G4StackManager()

G4StackManager::G4StackManager

(

)

Definition at line 39 of file G4StackManager.cc.

:userStackingAction(0),verboseLevel(0),numberOfAdditionalWaitingStacks(0)
{
  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 54 of file G4StackManager.cc.

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

Member Function Documentation

clear()

void G4StackManager::clear

(

)

Definition at line 454 of file G4StackManager.cc.

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

Referenced by G4EventManager::AbortCurrentEvent().

ClearPostponeStack()

void G4StackManager::ClearPostponeStack

(

)

Definition at line 475 of file G4StackManager.cc.

{
  postponeStack->clearAndDestroy();
}

Referenced by G4StackingMessenger::SetNewValue().

ClearUrgentStack()

void G4StackManager::ClearUrgentStack

(

)

Definition at line 461 of file G4StackManager.cc.

{
  urgentStack->clearAndDestroy();
}

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

ClearWaitingStack()

void G4StackManager::ClearWaitingStack

(

int

i = 0

)

Definition at line 466 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 501 of file G4StackManager.cc.

{
  return postponeStack->GetNTrack();
}

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

GetNTotalTrack()

G4int G4StackManager::GetNTotalTrack

(

)

const

Definition at line 480 of file G4StackManager.cc.

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

GetNUrgentTrack()

G4int G4StackManager::GetNUrgentTrack

(

)

const

Definition at line 487 of file G4StackManager.cc.

{
  return urgentStack->GetNTrack();
}

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

GetNWaitingTrack()

G4int G4StackManager::GetNWaitingTrack

(

int

i = 0

)

const

Definition at line 492 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().

PopNextTrack()

G4Track * G4StackManager::PopNextTrack

(

G4VTrajectory **

newTrajectory

)

Definition at line 135 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(int i=0;i<numberOfAdditionalWaitingStacks;i++) {
        if(i==0) {
          additionalWaitingStacks[0]->TransferTo(waitingStack);
        } else {
          additionalWaitingStacks[i]->TransferTo(additionalWaitingStacks[i-1]);
        }
      }
    }
    if(userStackingAction) 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 232 of file G4StackManager.cc.

{
  if(userStackingAction) userStackingAction->PrepareNewEvent();
  
  urgentStack->clearAndDestroy(); // Set the urgentStack in a defined state. Not doing it would affect reproducibility.
  
  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 = 0
	)

Definition at line 82 of file G4StackManager.cc.

{
  G4ClassificationOfNewTrack classification;
  if(userStackingAction) 
  { classification = userStackingAction->ClassifyNewTrack( newTrack ); }
  else
  { classification = DefaultClassification( 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 188 of file G4StackManager.cc.

{
  G4StackedTrack aStackedTrack;
  G4TrackStack tmpStack;
  
  if( !userStackingAction ) 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;
    }
  }
}

SetNumberOfAdditionalWaitingStacks()

void G4StackManager::SetNumberOfAdditionalWaitingStacks

(

G4int

iAdd

)

Definition at line 304 of file G4StackManager.cc.

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

Referenced by G4EventManager::SetNumberOfAdditionalWaitingStacks().

SetUserStackingAction()

void G4StackManager::SetUserStackingAction

(

G4UserStackingAction *

value

)

Definition at line 511 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 506 of file G4StackManager.cc.

{
  verboseLevel = value;
}

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

TransferOneStackedTrack()

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

Definition at line 385 of file G4StackManager.cc.

{
  if(origin==destination) return;
  if(origin==fKill) return;
  G4TrackStack* originStack = 0;
  switch(origin)
  {
    case fUrgent:
      originStack = 0;
      break;
    case fWaiting:
      originStack = waitingStack;
      break;
    case fPostpone:
      originStack = postponeStack;
      break;
    default:
      int i = origin - 10;
      if(i<=numberOfAdditionalWaitingStacks) originStack = additionalWaitingStacks[i-1];
      break;
  }
  
  G4StackedTrack aStackedTrack;
  if(destination==fKill)
  {
    if( originStack && 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 = 0;
    switch(destination)
    {
      case fUrgent:
        targetStack = 0;
        break;
      case fWaiting:
        targetStack = waitingStack;
        break;
      case fPostpone:
        targetStack = postponeStack;
        break;
      default:
        int 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 324 of file G4StackManager.cc.

{
  if(origin==destination) return;
  if(origin==fKill) return;
  G4TrackStack* originStack = 0;
  switch(origin)
  {
    case fUrgent:
      originStack = 0;
      break;
    case fWaiting:
      originStack = waitingStack;
      break;
    case fPostpone:
      originStack = postponeStack;
      break;
    default:
      int i = origin - 10;
      if(i<=numberOfAdditionalWaitingStacks) originStack = additionalWaitingStacks[i-1];
      break;
  }
  
  if(destination==fKill)
  {
    if(originStack)
    { originStack->clearAndDestroy(); }
    else
    { urgentStack->clearAndDestroy(); }
  }
  else
  {
    G4TrackStack* targetStack = 0;
    switch(destination)
    {
      case fUrgent:
        targetStack = 0;
        break;
      case fWaiting:
        targetStack = waitingStack;
        break;
      case fPostpone:
        targetStack = postponeStack;
        break;
      default:
        int i = destination - 10;
        if(i<=numberOfAdditionalWaitingStacks) targetStack = additionalWaitingStacks[i-1];
        break;
    }
    if(originStack)
    {
      if(targetStack)
      { 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