Geant4ActionContainer.h

Go to the documentation of this file.

// $Id$
//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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 DD4HEP_DDG4_GEANT4ACTIONCONTAINER_H
#define DD4HEP_DDG4_GEANT4ACTIONCONTAINER_H

// Framework include files
#include "DD4hep/Printout.h"
#include "DDG4/Geant4Primitives.h"
#include "DDG4/Geant4Action.h"

// C/C++ include files
#include <map>
#include <string>
#include <typeinfo>

namespace DD4hep {

  namespace Simulation {

    // 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;

      Geant4GeneratorActionSequence*      m_generatorAction;
      Geant4RunActionSequence*            m_runAction;
      Geant4EventActionSequence*          m_eventAction;
      Geant4TrackingActionSequence*       m_trackingAction;
      Geant4SteppingActionSequence*       m_steppingAction;
      Geant4StackingActionSequence*       m_stackingAction;
      Geant4DetectorConstructionSequence* m_constructionAction;

      Geant4SensDetSequences*             m_sensDetActions;
      Geant4PhysicsListActionSequence*    m_physicsList;
      Geant4UserInitializationSequence*   m_userInit;

      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 Simulation
}      // End namespace DD4hep
#endif // DD4HEP_DDG4_GEANT4KERNEL_H