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

(

)

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

(

)

Definition at line 54 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(int i=0;i<numberOfAdditionalWaitingStacks;i++) {
      delete additionalWaitingStacks[i];
    }
  }
}

Here is the call graph for this function:

Member Function Documentation

void G4StackManager::clear

(

)

Definition at line 534 of file G4StackManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4StackManager::ClearPostponeStack

(

)

Definition at line 555 of file G4StackManager.cc.

{
  postponeStack->clearAndDestroy();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4StackManager::ClearUrgentStack

(

)

Definition at line 541 of file G4StackManager.cc.

{
  urgentStack->clearAndDestroy();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4StackManager::ClearWaitingStack

(

int

i = 0

)

Definition at line 546 of file G4StackManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4StackManager::GetNPostponedTrack

(

)

const

Definition at line 581 of file G4StackManager.cc.

{
  return postponeStack->GetNTrack();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4StackManager::GetNTotalTrack

(

)

const

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

Here is the call graph for this function:

G4int G4StackManager::GetNUrgentTrack

(

)

const

Definition at line 567 of file G4StackManager.cc.

{
  return urgentStack->GetNTrack();
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4StackManager::GetNWaitingTrack

(

int

i = 0

)

const

Definition at line 572 of file G4StackManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4Track * G4StackManager::PopNextTrack

(

G4VTrajectory **

newTrajectory

)

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

Here is the call graph for this function:

G4int G4StackManager::PrepareNewEvent

(

)

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

Here is the call graph for this function:

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

Definition at line 92 of file G4StackManager.cc.

{
  const G4ParticleDefinition* pd = newTrack->GetParticleDefinition();
  if(pd->GetParticleDefinitionID() < 0)
  {
#ifdef G4VERBOSE
    G4ExceptionDescription ED;
    if(verboseLevel>0) {
      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."; }
      }
    }
#endif
    if(pd->IsGeneralIon())
    {
#ifdef G4VERBOSE
      if( verboseLevel > 0 ) {
        ED << "\n Process manager is temporally set, but this operation is thread-unsafe\n"
           << "and will be replaced with other methods at version 10.0.";
        G4Exception("G4StackManager::PushOneTrack","Event10051",JustWarning,ED);
      }
#endif
      G4ParticleDefinition* genericIon = G4ParticleTable::GetParticleTable()->GetGenericIon();
      G4ProcessManager* pman=0;
      if (genericIon!=0) pman = genericIon->GetProcessManager();
      if ((genericIon ==0) || (pman==0)){
        G4Exception( "G4IonTable::AddProcessManager()","PART10052", FatalException,
                   "Can not define process manager. GenericIon is not available.");
      }
      G4ParticleDefinition* ion = const_cast<G4ParticleDefinition*>(pd);
      ion->SetParticleDefinitionID(genericIon->GetParticleDefinitionID());
#ifdef G4VERBOSE
      if( verboseLevel > 1 )
      {
        G4ProcessManager* ionPman = ion->GetProcessManager();
        G4cout << "Now " << ion->GetParticleName() << " has a process manaegr at " << ionPman
               << " that is equivalent to " << pman << G4endl;
        G4ProcessVector* ionPvec = ionPman->GetProcessList();
        for(G4int ip1=0;ip1<ionPvec->size();ip1++)
        {
          G4cout << " " << ip1 << " - " << (*ionPvec)[ip1]->GetProcessName()
                 << " AtRest " << ionPman->GetAtRestIndex((*ionPvec)[ip1])
                 << ", AlongStep " << ionPman->GetAlongStepIndex((*ionPvec)[ip1])
                 << ", PostStep " << ionPman->GetPostStepIndex((*ionPvec)[ip1])
                 << G4endl;
        }
      }
#endif
    }
    else
    {
#ifdef G4VERBOSE
      if( verboseLevel > 0 ) {
        ED << "\nThis track is deleted.";
        G4Exception("G4StackManager::PushOneTrack","Event10051",
                 JustWarning,ED);
      }
#endif
      delete newTrack;
      return GetNUrgentTrack();
    }
  }
    
  G4ClassificationOfNewTrack classification = DefaultClassification( newTrack ); 
  if(userStackingAction) 
  { 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();
}

Here is the call graph for this function:

void G4StackManager::ReClassify

(

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4StackManager::SetNumberOfAdditionalWaitingStacks

(

G4int

iAdd

)

Definition at line 384 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];
    }
  }
}

Here is the caller graph for this function:

void G4StackManager::SetUserStackingAction

(

G4UserStackingAction *

value

)

Definition at line 591 of file G4StackManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4StackManager::SetVerboseLevel

(

G4int const

value

)

Definition at line 586 of file G4StackManager.cc.

{
  verboseLevel = value;
}

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

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

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

Here is the call graph for this function:

---

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

• geant4.10.03.p01/source/event/include/G4StackManager.hh
• geant4.10.03.p01/source/event/src/G4StackManager.cc