Geant4SensDetAction.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_GEANT4SENSDETACTION_H
#define DDG4_GEANT4SENSDETACTION_H
 
// Framework include files
#include <DD4hep/Detector.h>
#include <DDG4/Geant4Action.h>
#include <DDG4/Geant4HitCollection.h>
 
// Geant4 include files
#include <G4ThreeVector.hh>
#include <G4VTouchable.hh>
 
// C/C++ include files
#include <vector>
 
// Forward declarations
class G4HCofThisEvent;
class G4Step;
class G4Event;
class G4TouchableHistory;
class G4VHitsCollection;
class G4VReadOutGeometry;
 
namespace dd4hep {
 
  // Forward declarations
  class Detector;
  class DetElement;
  class SensitiveDetector;
 
  namespace sim {
 
    // Forward declarations
    class Geant4Sensitive;
    class Geant4FastSimSpot;
    class Geant4StepHandler;
    class Geant4HitCollection;
    class Geant4SensDetActionSequence;
    class Geant4SensDetSequences;
 
 
    class Geant4ActionSD: virtual public Geant4Action {
    protected:
      DDG4_DEFINE_ACTION_CONSTRUCTORS(Geant4ActionSD);
      Geant4ActionSD(const std::string& name);
      virtual ~Geant4ActionSD();
    public:
      virtual std::size_t defineCollection(const std::string& name) = 0;
      virtual G4VReadOutGeometry* readoutGeometry() const = 0;
      virtual G4int GetCollectionID(G4int i) = 0;
      virtual bool isActive() const = 0;
      virtual SensitiveDetector sensitiveDetector() const = 0;
      virtual std::string path() const = 0;
      virtual std::string fullPath() const = 0;
      virtual const std::string& sensitiveType() const = 0;
    };
 
 
    class Geant4Filter: public Geant4Action {
    protected:
      DDG4_DEFINE_ACTION_CONSTRUCTORS(Geant4Filter);
 
    public:
      Geant4Filter(Geant4Context* context, const std::string& name);
      virtual ~Geant4Filter();
 
      virtual bool operator()(const G4Step* step) const;
 
 
      virtual bool operator()(const Geant4FastSimSpot* spot) const;
    };
 
 
    class Geant4Sensitive: public Geant4Action {
    public:
      enum HitCreationFlags {
        SIMPLE_MODE = 0,
        MEDIUM_MODE = 1<<0,
        DETAILED_MODE = 1<<1
      };
 
    private:
      Geant4ActionSD* m_sensitiveDetector     { nullptr };
      Geant4SensDetActionSequence* m_sequence { nullptr };
 
    protected:
      int  m_hitCreationMode                  {       0 };
      bool m_useVolumeManager                 {    true };
 
#if defined(G__ROOT) || defined(__CLING__) || defined(__ROOTCLING__)
      Detector*            m_detDesc          { nullptr };
#else
      Detector&            m_detDesc;
#endif
      DetElement           m_detector         {  };
      SensitiveDetector    m_sensitive        {  };
      Readout              m_readout          {  };
      Segmentation         m_segmentation     {  };
      Actors<Geant4Filter> m_filters;
 
      DDG4_DEFINE_ACTION_CONSTRUCTORS(Geant4Sensitive);
 
    public:
      Geant4Sensitive(Geant4Context* context, const std::string& name, DetElement det, Detector& description);
 
      virtual ~Geant4Sensitive();
 
      int id()  const;
  
      Geant4ActionSD& detector() const;
 
      void setDetector(Geant4ActionSD* sens_det);
 
      bool useVolumeManager()  const  {
        return m_useVolumeManager;
      }
 
      int hitCreationMode() const  {
        return m_hitCreationMode;
      }
 
      std::string detectorName() const {
        return detector().name();
      }
 
      std::string path() const {
        return detector().path();
      }
 
      std::string fullPath() const {
        return detector().fullPath();
      }
 
      bool isActive() const {
        return detector().isActive();
      }
 
      SensitiveDetector sensitiveDetector() const  {
        return m_sensitive;
      }
 
      G4VReadOutGeometry* readoutGeometry() const {
        return detector().readoutGeometry();
      }
 
      Detector& detectorDescription()   const;
 
      void mark(const G4Track* track) const;
 
      void mark(const G4Step* step) const;
 
      Geant4SensDetActionSequence& sequence() const;
 
      void adopt(Geant4Filter* filter);
 
      void adopt_front(Geant4Filter* filter);
 
      void adoptFilter(Geant4Action* filter);
 
      void adoptFilter_front(Geant4Action* filter);
 
 
      bool accept(const G4Step* step) const;
 
 
      bool accept(const Geant4FastSimSpot* step) const;
 
      template <typename TYPE> std::size_t defineCollection(const std::string& coll_name);
 
      const std::string& hitCollectionName(std::size_t which) const;
 
      Geant4HitCollection* collection(std::size_t which);
 
      Geant4HitCollection* collectionByID(std::size_t id);
 
      virtual void defineCollections();
 
 
      virtual void begin(G4HCofThisEvent* hce);
 
      virtual void end(G4HCofThisEvent* hce);
 
 
      virtual void clear(G4HCofThisEvent* hce);
 
 
      long long int volumeID(const G4Step* step);
 
 
      long long int volumeID(const G4VTouchable* touchable);
 
 
      long long int cellID(const G4Step* step);
 
 
      long long int cellID(const G4VTouchable* touchable, const G4ThreeVector& global);
 
      virtual bool process(const G4Step* step, G4TouchableHistory* history);
 
 
      virtual bool processFastSim(const Geant4FastSimSpot* spot, G4TouchableHistory* history);
    };
 
 
    class Geant4SensDetActionSequence: public Geant4Action {
    public:
      typedef Geant4HitCollection* (*create_t)(const std::string&, const std::string&, Geant4Sensitive*);
      typedef std::pair<std::string, std::pair<Geant4Sensitive*,create_t> > HitCollection;
      typedef std::vector<HitCollection> HitCollections;
 
    protected:
      G4HCofThisEvent*        m_hce  { nullptr };
      CallbackSequence        m_begin;
      CallbackSequence        m_end;
      CallbackSequence        m_process;
      CallbackSequence        m_clear;
      Actors<Geant4Sensitive> m_actors;
      Actors<Geant4Filter>    m_filters;
 
      HitCollections          m_collections;
      SensitiveDetector       m_sensitive;
      Geant4ActionSD*         m_detector;
      std::string             m_sensitiveType;
      template <typename TYPE> static 
      Geant4HitCollection* _create(const std::string& det, const std::string& coll, Geant4Sensitive* sd) {
        return new Geant4HitCollection(det, coll, sd, (TYPE*) 0);
      }
 
    protected:
      DDG4_DEFINE_ACTION_CONSTRUCTORS(Geant4SensDetActionSequence);
 
    public:
      Geant4SensDetActionSequence(Geant4Context* context, const std::string& name);
 
      virtual ~Geant4SensDetActionSequence();
 
      virtual const std::string& sensitiveType() const   {
        return m_sensitiveType;
      }
 
      virtual void updateContext(Geant4Context* ctxt)  override;
 
      std::size_t defineCollections(Geant4ActionSD* sens_det);
 
      std::size_t defineCollection(Geant4Sensitive* owner, const std::string& name, create_t func);
 
      template <typename TYPE> std::size_t defineCollection(Geant4Sensitive* owner, const std::string& coll_name) {
        return defineCollection(owner, coll_name, Geant4SensDetActionSequence::_create<TYPE>);
      }
 
      const std::string& hitCollectionName(std::size_t which) const;
 
      Geant4HitCollection* collection(std::size_t which) const;
 
      Geant4HitCollection* collectionByID(std::size_t id) const;
 
      template <typename T> void callAtBegin(T* p, void (T::*f)(G4HCofThisEvent*)) {
        m_begin.add(p, f);
      }
 
      template <typename T> void callAtEnd(T* p, void (T::*f)(G4HCofThisEvent*)) {
        m_end.add(p, f);
      }
 
      template <typename T> void callAtProcess(T* p, void (T::*f)(G4Step*, G4TouchableHistory*)) {
        m_process.add(p, f);
      }
 
      template <typename T> void callAtClear(T* p, void (T::*f)(G4HCofThisEvent*)) {
        m_clear.add(p, f);
      }
 
      void adopt(Geant4Sensitive* sensitive);
 
      void adopt(Geant4Filter* filter);
 
      void adoptFilter(Geant4Action* filter);
 
      bool accept(const G4Step* step) const;
 
      bool accept(const Geant4FastSimSpot* step) const;
 
 
      virtual void begin(G4HCofThisEvent* hce);
 
 
      virtual void end(G4HCofThisEvent* hce);
 
      virtual void clear();
 
      virtual bool process(const G4Step* step, G4TouchableHistory* history);
 
      virtual bool processFastSim(const Geant4FastSimSpot* spot, G4TouchableHistory* history);
    };
 
 
    class Geant4SensDetSequences {
    public:
      friend class Geant4ActionContainer;
      friend class Geant4SensDetActionSequence;
      typedef std::map<std::string, Geant4SensDetActionSequence*> Members;
    private:
      Members m_sequences;
      void insert(const std::string& name, Geant4SensDetActionSequence* seq);
 
    public:
      Geant4SensDetSequences() = default;
      virtual ~Geant4SensDetSequences();
      Geant4SensDetActionSequence* operator[](const std::string& name) const;
      Geant4SensDetActionSequence* find(const std::string& name) const;
      Members& sequences() {
        return m_sequences;
      }
      const Members& sequences() const {
        return m_sequences;
      }
      void clear();
    };
 
    template <typename TYPE> inline std::size_t Geant4Sensitive::defineCollection(const std::string& coll_name) {
      return sequence().defineCollection<TYPE>(this, coll_name);
    }
 
 
    template <typename T> class Geant4SensitiveAction : public Geant4Sensitive  {
    public:
      typedef T UserData;
    protected:
      std::string m_collectionName  {   };
      std::string m_readoutName     {   };
 
      std::size_t m_collectionID    { 0 };
      UserData    m_userData        {   };
 
    protected:
      DDG4_DEFINE_ACTION_CONSTRUCTORS(Geant4SensitiveAction);
 
    public:
      Geant4SensitiveAction(Geant4Context* context,
                            const std::string& name,
                            DetElement det,
                            Detector& description);
 
      virtual ~Geant4SensitiveAction();
 
      void declareOptionalProperties();
 
      virtual void defineCollections();
 
      Readout readout();
      
 
      template <typename HIT> std::size_t declareReadoutFilteredCollection();
 
      template <typename HIT> 
      std::size_t defineReadoutCollection(const std::string collection_name);
 
      virtual void initialize()  final;
      virtual void finalize()  final;
 
      virtual void begin(G4HCofThisEvent* hce)  final;
      virtual void end(G4HCofThisEvent* hce)  final;
      virtual void clear(G4HCofThisEvent* hce)  final;
 
      virtual bool process(const G4Step* step,G4TouchableHistory* history)  final;
 
      virtual bool processFastSim(const Geant4FastSimSpot* spot, G4TouchableHistory* history)  final;
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4SENSDETACTION_H