Geant4ActionContainer.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DDG4_GEANT4ACTIONCONTAINER_H
#define DDG4_GEANT4ACTIONCONTAINER_H
 
// Framework include files
#include <DD4hep/Printout.h>
#include <DDG4/Geant4Action.h>
#include <DDG4/Geant4Primitives.h>
 
// C/C++ include files
#include <map>
#include <string>
#include <typeinfo>
 
namespace dd4hep {
 
  namespace sim {
 
    // Forward declarations
    class Geant4Context;
    class Geant4Action;
    class Geant4RunAction;
    class Geant4EventAction;
    class Geant4SteppingAction;
    class Geant4TrackingAction;
    class Geant4StackingAction;
    class Geant4GeneratorAction;
    class Geant4PhysicsList;
    class Geant4RunActionSequence;
    class Geant4EventActionSequence;
    class Geant4SteppingActionSequence;
    class Geant4TrackingActionSequence;
    class Geant4StackingActionSequence;
    class Geant4GeneratorActionSequence;
    class Geant4PhysicsListActionSequence;
    class Geant4DetectorConstructionSequence;
    class Geant4UserInitializationSequence;
    class Geant4SensDetActionSequence;
    class Geant4SensDetSequences;
 
 
    class Geant4ActionContainer {
    protected:
 
      Geant4Context*                      m_context             { nullptr };
 
      Geant4GeneratorActionSequence*      m_generatorAction     { nullptr };
      Geant4RunActionSequence*            m_runAction           { nullptr };
      Geant4EventActionSequence*          m_eventAction         { nullptr };
      Geant4TrackingActionSequence*       m_trackingAction      { nullptr };
      Geant4SteppingActionSequence*       m_steppingAction      { nullptr };
      Geant4StackingActionSequence*       m_stackingAction      { nullptr };
      Geant4DetectorConstructionSequence* m_constructionAction  { nullptr };
 
      Geant4SensDetSequences*             m_sensDetActions      { nullptr };
      Geant4PhysicsListActionSequence*    m_physicsList         { nullptr };
      Geant4UserInitializationSequence*   m_userInit            { nullptr };
 
      template <typename C> bool registerSequence(C*& seq, const std::string& name);
 
      Geant4ActionContainer(Geant4Context* ctxt=0);
 
      virtual ~Geant4ActionContainer();
 
      void setContext(Geant4Context* ctxt);
 
    public:
      Geant4Context* workerContext();
 
      virtual int terminate();
 
      Geant4GeneratorActionSequence* generatorAction(bool create);
      Geant4GeneratorActionSequence& generatorAction() {
        return *generatorAction(true);
      }
 
      Geant4RunActionSequence* runAction(bool create);
      Geant4RunActionSequence& runAction() {
        return *runAction(true);
      }
 
      Geant4EventActionSequence* eventAction(bool create);
      Geant4EventActionSequence& eventAction() {
        return *eventAction(true);
      }
 
      Geant4SteppingActionSequence* steppingAction(bool create);
      Geant4SteppingActionSequence& steppingAction() {
        return *steppingAction(true);
      }
 
      Geant4TrackingActionSequence* trackingAction(bool create);
      Geant4TrackingActionSequence& trackingAction() {
        return *trackingAction(true);
      }
 
      Geant4StackingActionSequence* stackingAction(bool create);
      Geant4StackingActionSequence& stackingAction() {
        return *stackingAction(true);
      }
 
      Geant4DetectorConstructionSequence* detectorConstruction(bool create);
      Geant4DetectorConstructionSequence& detectorConstruction() {
        return *detectorConstruction(true);
      }
 
      Geant4SensDetSequences& sensitiveActions() const;
      Geant4SensDetActionSequence* sensitiveAction(const std::string& name);
 
      Geant4PhysicsListActionSequence* physicsList(bool create);
      Geant4PhysicsListActionSequence& physicsList() {
        return *physicsList(true);
      }
      Geant4UserInitializationSequence* userInitialization(bool create);
      Geant4UserInitializationSequence& userInitialization() {
        return *userInitialization(true);
      }
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4ACTIONCONTAINER_H