Geant4SensDet.cpp

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
//
//==========================================================================
 
// Framework include files
#include <DD4hep/Printout.h>
#include <DD4hep/Primitives.h>
#include <DD4hep/InstanceCount.h>
 
#include <DDG4/Geant4Kernel.h>
#include <DDG4/Geant4Context.h>
#include <DDG4/Geant4FastSimSpot.h>
#include <DDG4/Geant4HitCollection.h>
#include <DDG4/Geant4SensDetAction.h>
 
// Geant4 include files
#include <G4Run.hh>
#include <G4Event.hh>
#include <G4Version.hh>
#include <G4TouchableHistory.hh>
#include <G4VSensitiveDetector.hh>
#include <G4VGFlashSensitiveDetector.hh>
#if G4VERSION_NUMBER < 1070
class G4VFastSimSensitiveDetector  {
public:
  G4VFastSimSensitiveDetector() = default;
  virtual ~G4VFastSimSensitiveDetector() = default;
  virtual G4bool ProcessHits(const G4FastHit* hit,
                 const G4FastTrack* track,
                 G4TouchableHistory* hist) = 0;
};
#else
#include <G4VFastSimSensitiveDetector.hh>
#endif
 
namespace dd4hep {
 
  namespace sim {
 
 
    template <typename T> class RefCountedSequence  {
    public:
      T* m_sequence;
      RefCountedSequence() : m_sequence(0) {                 }
      RefCountedSequence(T* seq)           {   _aquire(seq); }
      virtual ~RefCountedSequence()        { _release();     }
      void _aquire(T* s)  {
        InstanceCount::increment(this);
        m_sequence = s;
        m_sequence->addRef();
      }
      void _release()  {
        detail::releasePtr(m_sequence);
        InstanceCount::decrement(this);
      }
    };
 
 
    class Geant4SensDet : virtual public G4VSensitiveDetector,
              virtual public G4VGFlashSensitiveDetector,
              virtual public G4VFastSimSensitiveDetector,
                          virtual public G4VSDFilter,
                          virtual public Geant4ActionSD,
                          virtual public RefCountedSequence<Geant4SensDetActionSequence>
    {
    protected:
      SensitiveDetector m_sensitive;
    public:
      Geant4SensDet(const std::string& nam, Detector& description)
        : G4VSensitiveDetector(nam),
      G4VGFlashSensitiveDetector(),
      G4VFastSimSensitiveDetector(),
      G4VSDFilter(nam),
          Geant4Action(0,nam),
      Geant4ActionSD(nam),
          RefCountedSequence<Geant4SensDetActionSequence>()
      {
        Geant4Kernel& master = Geant4Kernel::instance(description);
        Geant4Kernel& kernel = master.worker(Geant4Kernel::thread_self());
        m_sensitive   = description.sensitiveDetector(nam);
        m_context     = kernel.workerContext();
        m_outputLevel = kernel.getOutputLevel(nam);
        _aquire(kernel.sensitiveAction(nam));
        m_sequence->defineCollections(this);
        m_sequence->updateContext(m_context);
        this->G4VSensitiveDetector::SetFilter(this);
      }
 
      virtual ~Geant4SensDet() = default;
      inline G4String GetName() const
      {  return this->G4VSensitiveDetector::SensitiveDetectorName;      }
      virtual std::string path()  const  override  final
      {  return this->G4VSensitiveDetector::GetPathName();              }
      virtual std::string fullPath()  const  override  final
      {  return this->G4VSensitiveDetector::GetFullPathName();          }
      virtual bool isActive() const  override
      {  return this->G4VSensitiveDetector::isActive();                 }
      virtual G4int GetCollectionID(G4int i)  override  final
      {  return this->G4VSensitiveDetector::GetCollectionID(i);         }
      virtual G4VReadOutGeometry* readoutGeometry() const  override
      {  return this->G4VSensitiveDetector::GetROgeometry();            }
      virtual SensitiveDetector sensitiveDetector() const  override  final
      {  return m_sensitive;                                            }
      virtual const std::string& sensitiveType() const  override  final
      {  return m_sequence->sensitiveType();                            }
      virtual G4bool Accept(const G4Step* step) const  override  final
      {  return m_sequence->accept(step);                               }
      virtual void Initialize(G4HCofThisEvent* hce)  override  final
      {  m_sequence->begin(hce);                                        }
      virtual void EndOfEvent(G4HCofThisEvent* hce)  override  final
      {  m_sequence->end(hce);                                          }
      virtual G4bool ProcessHits(G4Step* step,
                 G4TouchableHistory* hist)   override  final
      {  return m_sequence->process(step,hist);                         }
      virtual G4bool ProcessHits(G4GFlashSpot* sp,
                 G4TouchableHistory* hist)   override final
      {
    const GFlashEnergySpot* esp = sp->GetEnergySpot();
    G4FastHit         hit(esp->GetPosition(), esp->GetEnergy());
    Geant4FastSimSpot spot(&hit, sp->GetOriginatorTrack(), (sp->GetTouchableHandle())());
    return m_sequence->processFastSim(&spot, hist);
      }
      virtual G4bool ProcessHits(const G4FastHit* hit,
                 const G4FastTrack* track,
                 G4TouchableHistory* hist)   override final
      {
    Geant4FastSimSpot spot(hit, track, hist);
    return m_sequence->processFastSim(&spot, hist);
      }
      virtual void clear()  override
      {  m_sequence->clear();                                           }
      virtual size_t defineCollection(const std::string& coll)   override  {
        if ( coll.empty() ) {
          except("Geant4Sensitive: No collection defined for %s [Invalid name]",c_name());
        }
        collectionName.emplace_back(coll);
        return collectionName.size()-1;
      }
 
    };
  }    // End namespace sim
}      // End namespace dd4hep
 
 
#include <DDG4/Factories.h>
 
typedef dd4hep::sim::Geant4SensDet Geant4SensDet;
typedef dd4hep::sim::Geant4SensDet Geant4tracker;
typedef dd4hep::sim::Geant4SensDet Geant4calorimeter;
 
DECLARE_GEANT4SENSITIVEDETECTOR(Geant4SensDet)
DECLARE_GEANT4SENSITIVEDETECTOR(Geant4tracker)
DECLARE_GEANT4SENSITIVEDETECTOR(Geant4calorimeter)