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.

References G4cout, G4endl, and G4TrackStack::GetMaxNTrack().

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

Member Function Documentation

void G4StackManager::clear

(

void

)

Definition at line 534 of file G4StackManager.cc.

References ClearUrgentStack(), and ClearWaitingStack().

Referenced by G4EventManager::AbortCurrentEvent(), export_G4StackManager(), ExN04StackingAction::NewStage(), and RE05StackingAction::NewStage().

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

void G4StackManager::ClearPostponeStack

(

)

Definition at line 555 of file G4StackManager.cc.

References G4TrackStack::clearAndDestroy().

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

{
  postponeStack->clearAndDestroy();
}

void G4StackManager::ClearUrgentStack

(

)

Definition at line 541 of file G4StackManager.cc.

References G4TrackStack::clearAndDestroy().

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

{
  urgentStack->clearAndDestroy();
}

void G4StackManager::ClearWaitingStack

(

int

i = 0

)

Definition at line 546 of file G4StackManager.cc.

References G4TrackStack::clearAndDestroy().

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

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

G4int G4StackManager::GetNPostponedTrack

(

)

const

Definition at line 581 of file G4StackManager.cc.

References G4TrackStack::GetNTrack().

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

{
  return postponeStack->GetNTrack();
}

G4int G4StackManager::GetNTotalTrack

(

)

const

Definition at line 560 of file G4StackManager.cc.

References G4TrackStack::GetNTrack(), and n.

Referenced by export_G4StackManager().

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

G4int G4StackManager::GetNUrgentTrack

(

)

const

Definition at line 567 of file G4StackManager.cc.

References G4TrackStack::GetNTrack().

Referenced by export_G4StackManager(), RE01StackingAction::NewStage(), CCalStackingAction::NewStage(), PopNextTrack(), PushOneTrack(), ReClassify(), and G4StackingMessenger::SetNewValue().

{
  return urgentStack->GetNTrack();
}

G4int G4StackManager::GetNWaitingTrack

(

int

i = 0

)

const

Definition at line 572 of file G4StackManager.cc.

References G4TrackStack::GetNTrack().

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

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

G4Track * G4StackManager::PopNextTrack

(

G4VTrajectory **

newTrajectory

)

Definition at line 215 of file G4StackManager.cc.

References G4cout, G4endl, GetNUrgentTrack(), GetNWaitingTrack(), G4Track::GetParentID(), G4StackedTrack::GetTrack(), G4Track::GetTrackID(), G4StackedTrack::GetTrajectory(), G4UserStackingAction::NewStage(), G4TrackStack::PopFromStack(), and G4TrackStack::TransferTo().

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

G4int G4StackManager::PrepareNewEvent

(

)

Definition at line 312 of file G4StackManager.cc.

References G4UserStackingAction::ClassifyNewTrack(), G4TrackStack::clearAndDestroy(), FatalException, fKill, fPostpone, fUrgent, fWaiting, G4cout, G4endl, G4Exception(), GetNPostponedTrack(), G4TrackStack::GetNTrack(), G4StackedTrack::GetTrack(), G4StackedTrack::GetTrajectory(), G4TrackStack::PopFromStack(), G4UserStackingAction::PrepareNewEvent(), G4TrackStack::PushToStack(), G4Track::SetParentID(), G4Track::SetTrackID(), and G4TrackStack::TransferTo().

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

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

Definition at line 92 of file G4StackManager.cc.

References G4UserStackingAction::ClassifyNewTrack(), FatalException, fKill, fPostpone, fUrgent, fWaiting, G4cout, G4endl, G4Exception(), G4ProcessManager::GetAlongStepIndex(), G4ProcessManager::GetAtRestIndex(), G4Track::GetCreatorProcess(), G4ParticleTable::GetGenericIon(), GetNUrgentTrack(), G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ProcessManager::GetPostStepIndex(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4Track::GetTrackID(), G4ParticleDefinition::IsGeneralIon(), JustWarning, G4TrackStack::PushToStack(), G4ParticleDefinition::SetParticleDefinitionID(), and G4ProcessVector::size().

{
  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
////  Temporal care of setting process manager for general ion.
    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
    }
////  End of temporal care of setting process manager
    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();
}

void G4StackManager::ReClassify

(

)

Definition at line 268 of file G4StackManager.cc.

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

Referenced by export_G4StackManager(), ExN04StackingAction::NewStage(), CCalStackingAction::NewStage(), and RE05StackingAction::NewStage().

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

void G4StackManager::SetNumberOfAdditionalWaitingStacks

(

G4int

iAdd

)

Definition at line 384 of file G4StackManager.cc.

Referenced by G4EventManager::SetNumberOfAdditionalWaitingStacks().

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

void G4StackManager::SetUserStackingAction

(

G4UserStackingAction *

value

)

Definition at line 591 of file G4StackManager.cc.

References G4UserStackingAction::SetStackManager().

Referenced by G4EventManager::SetUserAction().

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

void G4StackManager::SetVerboseLevel

(

G4int const

value

)

Definition at line 586 of file G4StackManager.cc.

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

{
  verboseLevel = value;
}

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

Definition at line 465 of file G4StackManager.cc.

References fKill, fPostpone, fUrgent, fWaiting, G4TrackStack::GetNTrack(), G4StackedTrack::GetTrack(), G4StackedTrack::GetTrajectory(), G4TrackStack::PopFromStack(), and G4TrackStack::PushToStack().

Referenced by RE01StackingAction::NewStage().

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

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

Definition at line 404 of file G4StackManager.cc.

References G4TrackStack::clearAndDestroy(), fKill, fPostpone, fUrgent, fWaiting, and G4TrackStack::TransferTo().

Referenced by RE01StackingAction::NewStage().

{
  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