g4b::UserActionManager Class Reference

#include <UserActionManager.h>

Inheritance diagram for g4b::UserActionManager:

Public Member Functions
virtual	~UserActionManager ()
void	Close ()
G4int	GetSize () const
UserAction *	GetAction (G4int i) const
UserAction *	GetAction (std::string const &name) const
G4int	GetIndex (std::string const &name) const
void	PrintActionList (std::string const &opt) const
virtual void	BeginOfRunAction (const G4Run *)
virtual void	EndOfRunAction (const G4Run *)
virtual void	BeginOfEventAction (const G4Event *)
virtual void	EndOfEventAction (const G4Event *)
virtual void	PreUserTrackingAction (const G4Track *)
virtual void	PostUserTrackingAction (const G4Track *)
virtual void	UserSteppingAction (const G4Step *)
virtual G4ClassificationOfNewTrack	ClassifyNewTrack (const G4Track *)
virtual void	NewStage ()
virtual void	PrepareNewEvent ()
virtual bool	DoesAnyActionProvideStacking ()
G4EventManager *	GetEventManager () const
G4TrackingManager *	GetTrackingManager () const
G4SteppingManager *	GetSteppingManager () const

Static Public Member Functions
static UserActionManager *	Instance ()
static void	AddAndAdoptAction (UserAction *a)

Protected Member Functions
	UserActionManager ()

Private Types
typedef std::vector< UserAction * >	fuserActions_t
typedef fuserActions_t::const_iterator	fuserActions_ptr_t

Static Private Attributes
static fuserActions_t	fuserActions

Detailed Description

Definition at line 60 of file UserActionManager.h.

Member Typedef Documentation

typedef fuserActions_t::const_iterator g4b::UserActionManager::fuserActions_ptr_t

private

Definition at line 112 of file UserActionManager.h.

typedef std::vector<UserAction*> g4b::UserActionManager::fuserActions_t

private

Definition at line 111 of file UserActionManager.h.

Constructor & Destructor Documentation

g4b::UserActionManager::~UserActionManager ( )

virtual

Definition at line 43 of file UserActionManager.cxx.

  {
    // This destructor is probably never going to be called.  If it
    // is, make sure all the UserAction classes we manage are deleted
    // properly.
    Close();
  }

g4b::UserActionManager::UserActionManager ( )

protected

Definition at line 30 of file UserActionManager.cxx.

  {
  }

Member Function Documentation

static void g4b::UserActionManager::AddAndAdoptAction ( UserAction *  a )

inlinestatic

Definition at line 82 of file UserActionManager.h.

{ fuserActions.push_back(a);  }

void g4b::UserActionManager::BeginOfEventAction ( const G4Event *  a_event )

virtual

Definition at line 122 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      (*i)->BeginOfEventAction(a_event);
    }
  }

void g4b::UserActionManager::BeginOfRunAction ( const G4Run *  a_run )

virtual

Definition at line 106 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      (*i)->BeginOfRunAction(a_run);
    }
  }

G4ClassificationOfNewTrack g4b::UserActionManager::ClassifyNewTrack ( const G4Track *  a_track )

virtual

Definition at line 163 of file UserActionManager.cxx.

  {
    std::map<G4ClassificationOfNewTrack,int> stackChoices;
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      if ( (*i)->ProvidesStacking() ) {
        G4ClassificationOfNewTrack choice = (*i)->StackClassifyNewTrack(a_track);
        stackChoices[choice]++;
      }
    }
    // based on all results pick an action
    //      fUrgent,    // put into the urgent stack
    //      fWaiting,   // put into the waiting stack
    //      fPostpone,  // postpone to the next event
    //      fKill       // kill without stacking

    //G4ClassificationOfNewTrack choice = fUrgent;  // safe choice
    // prioritize:  anyone shoots it, it's dead;
    //   then postpone; then waiting; finally just process it
    const G4ClassificationOfNewTrack priority[] = 
      { fKill, fPostpone, fWaiting, fUrgent };
    const size_t nprio = sizeof(priority)/sizeof(G4ClassificationOfNewTrack);
    for (unsigned int j=0; j<nprio; ++j) {
      G4ClassificationOfNewTrack saction = priority[j];
      if ( stackChoices[saction] > 0 ) return saction;
    } 
    // shouldn't get here (already covered) ... but a fall back
    return fUrgent;
  }

void g4b::UserActionManager::Close

(

void

)

Definition at line 53 of file UserActionManager.cxx.

  {
    // Since we adopted the pointers for the user-action classes we're
    // managing, delete all of them.
    for ( fuserActions_t::iterator i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      delete *i;
    }
  
    fuserActions.clear();
  }

bool g4b::UserActionManager::DoesAnyActionProvideStacking ( )

virtual

Definition at line 213 of file UserActionManager.cxx.

  {
    // do any managed UserActions do stacking?
    bool doany = false;
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      doany |= (*i)->ProvidesStacking();  // any == take the "or"
    }
    return doany;
  }

void g4b::UserActionManager::EndOfEventAction ( const G4Event *  a_event )

virtual

Definition at line 130 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ) {
      (*i)->EndOfEventAction(a_event);
    }
  }

void g4b::UserActionManager::EndOfRunAction ( const G4Run *  a_run )

virtual

Definition at line 114 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      (*i)->EndOfRunAction(a_run);
    }
  }

UserAction* g4b::UserActionManager::GetAction ( G4int  i ) const

inline

Definition at line 76 of file UserActionManager.h.

{ return fuserActions[i];     }

UserAction * g4b::UserActionManager::GetAction

(

std::string const &

name

)

const

Definition at line 76 of file UserActionManager.cxx.

  {
    G4int indx = GetIndex(name);
    if ( indx < 0 ) return 0;  // not found
    return fuserActions[indx];
  }

G4EventManager* g4b::UserActionManager::GetEventManager ( ) const

inline

Definition at line 106 of file UserActionManager.h.

{ return fpEventManager;    }

G4int g4b::UserActionManager::GetIndex

(

std::string const &

name

)

const

Definition at line 65 of file UserActionManager.cxx.

  {
    int indx=0;
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++, indx++ ){
      if ( (*i)->GetName() == name ) return indx;
    }
    // not found
    return -1;
  }

G4int g4b::UserActionManager::GetSize ( ) const

inline

Definition at line 75 of file UserActionManager.h.

{ return fuserActions.size(); }

G4SteppingManager* g4b::UserActionManager::GetSteppingManager ( ) const

inline

Definition at line 108 of file UserActionManager.h.

{ return fpSteppingManager; }

G4TrackingManager* g4b::UserActionManager::GetTrackingManager ( ) const

inline

Definition at line 107 of file UserActionManager.h.

{ return fpTrackingManager; }

UserActionManager * g4b::UserActionManager::Instance ( void  )

static

Definition at line 36 of file UserActionManager.cxx.

  {
    static UserActionManager instance;
    return &instance;
  }

void g4b::UserActionManager::NewStage ( )

virtual

Definition at line 193 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      if ( (*i)->ProvidesStacking() ) {
        (*i)->StackNewStage();
      }
    }
  }

void g4b::UserActionManager::PostUserTrackingAction ( const G4Track *  a_track )

virtual

Definition at line 146 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      (*i)->PostTrackingAction(a_track);
    }
  }

void g4b::UserActionManager::PrepareNewEvent ( )

virtual

Definition at line 203 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      if ( (*i)->ProvidesStacking() ) {
        (*i)->StackPrepareNewEvent();
      }
    }
  }

void g4b::UserActionManager::PreUserTrackingAction ( const G4Track *  a_track )

virtual

Definition at line 138 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      (*i)->PreTrackingAction(a_track);
    }
  }

void g4b::UserActionManager::PrintActionList

(

std::string const &

opt

)

const

Definition at line 84 of file UserActionManager.cxx.

  {
    bool pcfg = ( opt.find("config") != std::string::npos );
    std::cout << "UserActionManager::PrintActionList " << GetSize()
              << " entries" << std::endl;
    for ( G4int indx=0; indx < GetSize(); ++indx ) {
      UserAction* action = GetAction(indx);
      std::cout << "   [" << indx << "] " << action->GetName()
                << ( action->ProvidesStacking() ? " [stacking]":"" )
                << std::endl;
      if ( pcfg ) action->PrintConfig(opt);
    }
  }

void g4b::UserActionManager::UserSteppingAction ( const G4Step *  a_step )

virtual

Definition at line 154 of file UserActionManager.cxx.

  {
    for ( fuserActions_ptr_t i = fuserActions.begin(); i != fuserActions.end(); i++ ){
      (*i)->SteppingAction(a_step);
    }
  }

Member Data Documentation

UserActionManager::fuserActions_t g4b::UserActionManager::fuserActions

staticprivate

Definition at line 113 of file UserActionManager.h.

---

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

• nutools/old/G4Base/UserActionManager.h
• nutools/old/G4Base/UserActionManager.cxx