Geant4Customization.h

Go to the documentation of this file.

#ifndef _tls_Geant4Customization_h_
#define _tls_Geant4Customization_h_

#include <tls/G4VPhysicsListCustomization.h>

#include <G4VUserDetectorConstruction.hh>
#include <G4VUserPrimaryGeneratorAction.hh>
#include <G4UserStackingAction.hh>
#include <G4UserTrackingAction.hh>
#include <G4UserSteppingAction.hh>
#include <G4UserEventAction.hh>
#include <G4UserRunAction.hh>
#include <G4RunManager.hh>

#include <boost/shared_ptr.hpp>

#include <string>


namespace tls {

  class Geant4Customization {
  public:
    Geant4Customization() { }
    Geant4Customization(const std::string& name,
                        G4VUserDetectorConstruction* const construction = nullptr,
                        G4VUserPhysicsList* const physicsList = nullptr,
                        G4VUserPrimaryGeneratorAction* const primaryGenerator = nullptr) :
      fName(name),
      fDetectorConstruction(construction),
      fPhysicsList(physicsList),
      fPrimaryGenerator(primaryGenerator)
    { }

    virtual ~Geant4Customization() = default;

    std::string GetName() const { return fName; }

    void SetPhysicsList(G4VUserPhysicsList* const physicsList)
    { fPhysicsList = physicsList; }

    void SetDetectorConstruction(G4VUserDetectorConstruction* const construction)
    { fDetectorConstruction = construction; }

    void SetStackingAction(G4UserStackingAction* const action)
    { fStackingAction.reset(action); }
    void SetTrackingAction(G4UserTrackingAction* const action)
    { fTrackingAction.reset(action); }
    void SetSteppingAction(G4UserSteppingAction* const action)
    { fSteppingAction.reset(action); }
    void SetEventAction(G4UserEventAction* const action)
    { fEventAction.reset(action); }
    void SetRunAction(G4UserRunAction* const action)
    { fRunAction.reset(action); }

    void SetPrimaryGenerator(G4VUserPrimaryGeneratorAction* const action)
    { fPrimaryGenerator.reset(action); }

    G4VUserDetectorConstruction* GetDetectorConstruction()
    { return fDetectorConstruction; }
    G4VUserPhysicsList* GetPhysicsList() { return fPhysicsList; }
    G4VPhysicsListCustomization* GetPhysicsListCustomization()
    { return dynamic_cast<G4VPhysicsListCustomization*>(fPhysicsList); }

    G4UserStackingAction* GetStackingAction()
    { return fStackingAction.get(); }
    G4UserTrackingAction* GetTrackingAction()
    { return fTrackingAction.get(); }
    G4UserSteppingAction* GetSteppingAction()
    { return fSteppingAction.get(); }
    G4UserEventAction* GetEventAction()
    { return fEventAction.get(); }
    G4UserRunAction* GetRunAction()
    { return fRunAction.get(); }

    G4VUserPrimaryGeneratorAction* GetPrimaryGenerator()
    { return fPrimaryGenerator.get(); }

    void SetRunManager(boost::shared_ptr<G4RunManager> action)
    { fG4RunManager = action; }

  private:
    std::string fName;

    // Can't delete construction neither before nor after run manager
    // Run manager destructor only seems to call the destructor for
    // the current construction and they never get deleted as result.
    G4VUserDetectorConstruction* fDetectorConstruction = nullptr;

    // Physics list is owned by the global physics list.
    G4VUserPhysicsList* fPhysicsList = nullptr;

    boost::shared_ptr<G4VUserPrimaryGeneratorAction> fPrimaryGenerator;

    boost::shared_ptr<G4UserStackingAction> fStackingAction;
    boost::shared_ptr<G4UserTrackingAction> fTrackingAction;
    boost::shared_ptr<G4UserSteppingAction> fSteppingAction;
    boost::shared_ptr<G4UserEventAction> fEventAction;
    boost::shared_ptr<G4UserRunAction> fRunAction;

    boost::shared_ptr<G4RunManager> fG4RunManager;

  };

}


#endif