UserActionManager.h

Go to the documentation of this file.

#ifndef G4BASE_UserActionManager_H
#define G4BASE_UserActionManager_H

#include "nug4/G4Base/UserAction.h"

#include "Geant4/G4UserRunAction.hh"
#include "Geant4/G4UserEventAction.hh"
#include "Geant4/G4UserTrackingAction.hh"
#include "Geant4/G4UserSteppingAction.hh"
#include "Geant4/G4UserStackingAction.hh"

#include "Geant4/G4Run.hh"
#include "Geant4/G4Event.hh"
#include "Geant4/G4Track.hh"
#include "Geant4/G4Step.hh"

#include "Geant4/G4EventManager.hh"
#include "Geant4/G4TrackingManager.hh"
#include "Geant4/G4SteppingManager.hh"

#include <vector>

namespace g4b {

  class UserActionManager : public G4UserRunAction
                          , public G4UserEventAction
                          , public G4UserTrackingAction
                          , public G4UserSteppingAction 
                          , public G4UserStackingAction {
  public:
  
    // Access to instance:
    static UserActionManager* Instance();

    virtual ~UserActionManager();
  
    // Delete all the UserAction classes we manage.
    void Close();

    G4int       GetSize()                 const { return fuserActions.size(); }
    UserAction* GetAction(G4int i)        const { return fuserActions[i];     }
    UserAction* GetAction(std::string const& name) const;
    G4int       GetIndex(std::string const& name) const;

    void        PrintActionList(std::string const& opt) const;

    static void AddAndAdoptAction(UserAction* a){ fuserActions.push_back(a);  }

    // G4UserRunAction interfaces
    virtual void BeginOfRunAction      (const G4Run*  );
    virtual void EndOfRunAction        (const G4Run*  );
    // G4UserEventAction interfaces
    virtual void BeginOfEventAction    (const G4Event*);
    virtual void EndOfEventAction      (const G4Event*);
    // G4UserTrackingAction interfaces
    virtual void PreUserTrackingAction (const G4Track*);
    virtual void PostUserTrackingAction(const G4Track*);
    // G4UserSteppingAction interface
    virtual void UserSteppingAction    (const G4Step* );
    // G4UserStackingAction interfaces
    virtual G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track*);
    virtual void NewStage();
    virtual void PrepareNewEvent();
    virtual bool DoesAnyActionProvideStacking();  // do any managed UserActions do stacking

    // "Mysterious accessors": Where do the pointers to these managers
    // come from?  They are all defined in the G4User*Action classes.
    // Use care when calling these accessors; for example, the
    // SteppingManager is probably not available in a TrackingAction
    // method.  Keep the heirarchy in mind: Run > Event > Track > Step.
    G4EventManager*    GetEventManager()    const { return fpEventManager;    }
    G4TrackingManager* GetTrackingManager() const { return fpTrackingManager; }
    G4SteppingManager* GetSteppingManager() const { return fpSteppingManager; }

  private:
    typedef std::vector<UserAction*>       fuserActions_t;
    typedef fuserActions_t::const_iterator fuserActions_ptr_t;
    static  fuserActions_t                 fuserActions; 

  protected:
    // The constructor is protected according to the standard
    // singleton pattern.
    UserActionManager();
  
  };

} // namespace g4b

#endif // G4BASE_UserActionManager_H