SToGS_UserActionInitialization.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//

#ifndef SToGS_UserActionInitialization_h
#define SToGS_UserActionInitialization_h 1

#include "G4Version.hh"
#include "G4ios.hh"
#include "G4String.hh"
#include "G4UserRunAction.hh"
#include "G4UserEventAction.hh"
#include "G4UserTrackingAction.hh"
#include "G4UserSteppingAction.hh"

#if G4VERSION_NUMBER < 1000
#else
#include "G4VUserActionInitialization.hh"
#endif

#include <vector>
#include <utility>

class G4VSensitiveDetector;
class G4VUserPrimaryGeneratorAction;


namespace SToGS {

    class AllActions : virtual public G4UserRunAction, virtual public G4UserEventAction, virtual public G4UserTrackingAction, virtual public G4UserSteppingAction
    {
    protected:
        G4String fOption;
        
    public:
        AllActions(G4String opt): G4UserRunAction(), G4UserEventAction(), G4UserTrackingAction(), G4UserSteppingAction(), fOption(opt)
            {;}
        virtual ~AllActions()
            {;}
        
        virtual G4Run* GenerateRun()
        {
            return 0x0;
        }
        virtual void BeginOfRunAction(const G4Run * /*therun*/)
        {
            ;
        }
        virtual void EndOfRunAction(const G4Run * /*therun*/)
        {
            ;
        }
        virtual void BeginOfEventAction(const G4Event * /*event*/)
        {
            ;
        }
        virtual void EndOfEventAction(const G4Event * /*event*/)
        {
            ;
        }
        virtual void PreUserTrackingAction(const G4Track * /*atrack*/)
        {
            ;
        }
        virtual void PostUserTrackingAction(const G4Track * /*atrack*/)
        {
            ;
        }
        virtual void UserSteppingAction(const G4Step * /*step*/)
        {
            ;
        }
    };

    class RunAction : public G4UserRunAction
    {
    private:
        G4UserRunAction  *theRealAction;
    public:
        RunAction(G4UserRunAction *theaction = 0x0) : G4UserRunAction(), theRealAction(theaction)
            {;}
        virtual ~RunAction()
            {;}
        
    public:
        virtual G4Run* GenerateRun()
        {
            if (theRealAction)
                return theRealAction->GenerateRun();
            return G4UserRunAction::GenerateRun();
        }
        virtual void BeginOfRunAction(const G4Run *aRun)
        {
            if (theRealAction)
                theRealAction->BeginOfRunAction(aRun);
        }
        virtual void EndOfRunAction(const G4Run* aRun)
        {
            if (theRealAction)
                theRealAction->EndOfRunAction(aRun);
        }
        
    };

    class EventAction : public G4UserEventAction
    {
    private:
        G4UserEventAction *theRealAction;
    public:
        EventAction(G4UserEventAction *theaction = 0x0) : G4UserEventAction(), theRealAction(theaction)
            {;}
        virtual ~EventAction()
            {;}
    public:
        virtual void BeginOfEventAction(const G4Event *event)
        {
            if (theRealAction)
                theRealAction->BeginOfEventAction(event);
        }
        virtual void EndOfEventAction(const G4Event *event)
        {
            if (theRealAction)
                theRealAction->EndOfEventAction(event);
        }
    };

    class TrackingAction : public G4UserTrackingAction
    {
    private:
        G4UserTrackingAction *theRealAction;
    public:
        TrackingAction(G4UserTrackingAction *theaction = 0x0) : G4UserTrackingAction(), theRealAction(theaction)
            {;}
        virtual ~TrackingAction()
            {;}
    public:
        virtual void PreUserTrackingAction(const G4Track* atrack);
        virtual void PostUserTrackingAction(const G4Track *atrack);
    };

    class SteppingAction : public G4UserSteppingAction
    {
    private:
        G4UserSteppingAction *theRealAction;
    public:
        SteppingAction(G4UserSteppingAction *theaction = 0x0) : G4UserSteppingAction(), theRealAction(theaction)
            {;}
        virtual ~SteppingAction()
            {;}
    public:
        virtual void UserSteppingAction(const G4Step *step)
        {
            if (theRealAction)
                theRealAction->UserSteppingAction(step);
        }
    };


#if G4VERSION_NUMBER < 1000
    class UserActionInitialization
#else
    class UserActionInitialization : public G4VUserActionInitialization
#endif
    {
    protected:
        mutable std::vector < AllActions *> fAllUserAction;
        
    protected:
        G4String fUserActionOption;
        
    protected:
        std::pair < G4String, G4String > fWhichGenerator;

    protected:
        virtual G4VUserPrimaryGeneratorAction *GetGun(G4String which, G4String opt) const;

        void BuildAndRegister ( AllActions* ) const;
        void Register ( AllActions* ) const;
     
    public:
        UserActionInitialization(G4String which_user_action_opt, G4String which_gene, G4String which_gene_opt);
        virtual ~UserActionInitialization();
        

        std::pair < G4String, G4String > SetWhichGenerator(G4String which_gene, G4String option);
        
        static G4VSensitiveDetector *GetTrackerSD( G4String name = "/SToGS/SD/Tracker" );
        static G4VSensitiveDetector *GetCopClusterSD( G4String name = "/SToGS/SD/CopCluster" );
        
// INTERFACE provided for Geant4 < 10.0
    public:

        virtual G4VUserPrimaryGeneratorAction *GetGun() const;

        virtual G4UserRunAction *GetRunAction() const = 0;
        virtual G4UserEventAction *GetEventAction() const = 0;
        virtual G4UserTrackingAction *GetTrackingAction() const = 0;
        virtual G4UserSteppingAction *GetSteppingAction() const = 0;
        
// INTERFACE in principle required for Geant4 > 10.0
        virtual void    BuildForMaster () const
        {
            G4cout << " ------ INF ------ from SToGS::AllInOneUserActionInitialization::BuildForMaster() " << G4endl;
#if G4VERSION_NUMBER < 1000
            G4cout << " *** ERROR *** SToGS::AllInOneUserActionInitialization::BuildForMaster() should never be called by this version of Geant4 " << G4endl;
#else
            // As real work is done by slaves, default is not RunManager for Master. Could be changed by overloading this method
            SetUserAction( new SToGS::RunAction(0x0) ) ;
#endif
            G4cout << " ------ END ------  from SToGS::AllInOneUserActionInitialization::BuildForMaster() " << G4endl;
        }
        virtual void    Build () const = 0;
    };
    
    template<typename _T> class AllInOneUserActionInitialization : public UserActionInitialization
    {
    public:
        AllInOneUserActionInitialization(G4String which_user_action_opt, G4String which_gene, G4String which_gene_opt) :
            UserActionInitialization(which_user_action_opt,which_gene,which_gene_opt)
        {
            ;
        }
        virtual ~AllInOneUserActionInitialization()
        {
            ;
        }
        virtual G4UserRunAction *GetRunAction() const
        {
            if ( fAllUserAction.size() == 0 ) {
                fAllUserAction.push_back( new _T(fUserActionOption) );
            }
            return new SToGS::RunAction(fAllUserAction[0]);
        }
        virtual G4UserEventAction *GetEventAction() const
        {
            if ( fAllUserAction.size() == 0 ) {
                fAllUserAction.push_back( new _T(fUserActionOption) );
            }
            return new SToGS::EventAction(fAllUserAction[0]);
        }
        virtual G4UserTrackingAction *GetTrackingAction() const
        {
            if ( fAllUserAction.size() == 0 ) {
                fAllUserAction.push_back( new _T(fUserActionOption) );
            }
            return new SToGS::TrackingAction(fAllUserAction[0]);
        }
        virtual G4UserSteppingAction *GetSteppingAction() const
        {
            if ( fAllUserAction.size() == 0 ) {
                fAllUserAction.push_back( new _T(fUserActionOption) );
            }
            return new SToGS::SteppingAction(fAllUserAction[0]);
        }
        virtual void Build () const
        {
            BuildAndRegister( new _T(fUserActionOption) );
        }
    };
    
    
} // SToGS Namespace

#endif