Geant4Context.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_GEANT4CONTEXT_H
#define DDG4_GEANT4CONTEXT_H
 
// Framework incloude files
#include <DD4hep/Primitives.h>
#include <DD4hep/ObjectExtensions.h>
 
// Forward declarations
class G4Run;
class G4Track;
class G4Event;
class G4VTrajectory;
class G4VPhysicalVolume;
class G4TrackingManager;
 
namespace dd4hep {
 
  // Forward declarations
  class Detector;
  class DetElement;
 
  namespace sim {
 
    class Geant4Run;
    class Geant4Event;
    class Geant4Kernel;
    class Geant4Random;
    class ContextUpdate;
    class Geant4RunActionSequence;
    class Geant4EventActionSequence;
    class Geant4SteppingActionSequence;
    class Geant4TrackingActionSequence;
    class Geant4StackingActionSequence;
    class Geant4GeneratorActionSequence;
    class Geant4SensDetSequences;
 
 
    class  Geant4Run : public ObjectExtensions  {
      const G4Run* m_run { nullptr };
    protected:
 
    public:
      Geant4Run(const G4Run* run);
      virtual ~Geant4Run();
      operator const G4Run&() const  {  return *m_run;  }
      const G4Run& run() const       { return *m_run;   }
      void* addExtension(unsigned long long int k, ExtensionEntry* e)  {
        return ObjectExtensions::addExtension(k, e);
      }
      template <typename T> T* addExtension(T* ptr, bool take_ownership=true)   {
        ExtensionEntry* e = take_ownership
          ? (ExtensionEntry*)new detail::DeleteExtension<T,T>(ptr)
          : (ExtensionEntry*)new detail::SimpleExtension<T,T>(ptr);
        return (T*)ObjectExtensions::addExtension(detail::typeHash64<T>(),e);
      }
      template <typename T> T* extension(bool alert=true) {
        return (T*)ObjectExtensions::extension(detail::typeHash64<T>(),alert);
      }
    };
 
 
    class  Geant4Event : public ObjectExtensions  {
      const G4Event* m_event  { nullptr };
      Geant4Random* m_random  { nullptr };
 
    public:
      Geant4Event(const G4Event* run, Geant4Random* rndm);
      virtual ~Geant4Event();
      operator const G4Event&() const  {  return *m_event;   }
      const G4Event& event() const     {  return *m_event;   }
      Geant4Random& random() const     {  return *m_random;  }
 
      void* addExtension(unsigned long long int k, ExtensionEntry* e)  {
        return ObjectExtensions::addExtension(k, e);
      }
      template <typename T> T* addExtension(T* ptr, bool take_ownership=true)   {
        ExtensionEntry* e = take_ownership
          ? (ExtensionEntry*)new detail::DeleteExtension<T,T>(ptr)
          : (ExtensionEntry*)new detail::SimpleExtension<T,T>(ptr);
        return (T*)ObjectExtensions::addExtension(detail::typeHash64<T>(),e);
      }
      template <typename T> T* extension(bool alert=true) {
        return (T*)ObjectExtensions::extension(detail::typeHash64<T>(),alert);
      }
    };
 
 
    class Geant4Context  {
    public:
      friend class Geant4Kernel;
      typedef std::pair<void*, const std::type_info*>   UserFramework;
 
    protected:
      Geant4Kernel*      m_kernel = 0;
      Geant4Run*         m_run    = 0;
      Geant4Event*       m_event  = 0;
 
      Geant4Context(Geant4Kernel* kernel);
 
    public:
      virtual ~Geant4Context();
      void setRun(Geant4Run* new_run);
      Geant4Run& run()  const;
      Geant4Run* runPtr()  const  { return m_run; }
      void setEvent(Geant4Event* new_event);
      Geant4Event& event()  const;
      Geant4Event* eventPtr()  const     { return m_event; }
      Geant4Kernel& kernel()  const      { return *m_kernel;   }
      G4VPhysicalVolume* world()  const;
 
      template <typename T> T& framework()  const;
      UserFramework& userFramework() const;
      Detector& detectorDescription() const;
      G4TrackingManager* trackMgr() const;
      virtual G4VTrajectory* createTrajectory(const G4Track* track) const;
      Geant4RunActionSequence& runAction() const;
      Geant4EventActionSequence& eventAction() const;
      Geant4SteppingActionSequence& steppingAction() const;
      Geant4TrackingActionSequence& trackingAction() const;
      Geant4StackingActionSequence& stackingAction() const;
      Geant4GeneratorActionSequence& generatorAction() const;
      Geant4SensDetSequences& sensitiveActions() const;
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
 
#endif // DDG4_GEANT4CONTEXT_H