Geant4HitCollection.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_GEANT4HITCOLLECTION_H
#define DD4HEP_DDG4_GEANT4HITCOLLECTION_H

// Framework include files
#include "DD4hep/Handle.h"
#include "DDG4/ComponentUtils.h"
#include "G4VHitsCollection.hh"
#include "G4VHit.hh"

// C/C++ include files
#include <vector>
#include <string>
#include <climits>
#include <typeinfo>
#include <stdexcept>

namespace DD4hep {

  namespace Simulation {

    // Forward declarations
    class Geant4Sensitive;
    class Geant4HitCollection;
    class Geant4HitWrapper;


    class Geant4HitWrapper: public G4VHit {
    private:
    public:
      class InvalidHit {
      public:
        virtual ~InvalidHit();
      };


      class HitManipulator {
      public:
        typedef std::pair<void*, HitManipulator*> Wrapper;
#ifdef __CINT__
        const ComponentCast* cast;
        const ComponentCast* vec_type;
#else
        const ComponentCast& cast;
        const ComponentCast& vec_type;
#endif
        HitManipulator(const ComponentCast& c, const ComponentCast& v);
        ~HitManipulator();
        template <typename TYPE> Wrapper castHit(TYPE* obj) {
          if (obj) {
            ComponentCast& me = ComponentCast::instance<TYPE>();
            Wrapper wrap(obj, this);
            if (&cast == &me) {
              return wrap;
            }
            // Need to ensure that the container types are the same!
            wrap.first = me.apply_dynCast(cast, obj);
            return wrap;
          }
          throw std::runtime_error("Invalid hit pointer passed to collection!");
        }
        template <typename TYPE> static void deleteHit(Wrapper& obj) {
          TYPE* p = (TYPE*) obj.first;
          if (p)
            delete p;
          obj.first = 0;
        }
        template <typename TYPE> static HitManipulator* instance() {
          static HitManipulator hm(ComponentCast::instance<TYPE>(), ComponentCast::instance<std::vector<TYPE*> >());
          return &hm;
        }
      };

      typedef HitManipulator::Wrapper Wrapper;
    protected:
      mutable Wrapper m_data;

    public:

      Geant4HitWrapper() : G4VHit() {
        m_data.second = manipulator<InvalidHit>();
        m_data.first = 0;
      }
      Geant4HitWrapper(const Geant4HitWrapper& v) : G4VHit() {
        m_data = v.m_data;
        v.m_data.first = 0;
        //v.release();
      }
      Geant4HitWrapper(const Wrapper& v) : G4VHit()  {
        m_data = v;
      }
      virtual ~Geant4HitWrapper();
      void *operator new(size_t);
      void operator delete(void *ptr);
      void* release();
      Wrapper releaseData();
      HitManipulator* manip() const {
        return m_data.second;
      }
      void* data() {
        return m_data.first;
      }
      void* data() const {
        return m_data.first;
      }
      template <typename TYPE> static HitManipulator* manipulator() {
        return HitManipulator::instance<TYPE>();
      }
      Geant4HitWrapper& operator=(const Geant4HitWrapper& v) {
        if ( this != & v )  {
          m_data = v.m_data;
          v.m_data.first = 0;
          //v.release();
        }
        return *this;
      }
      template <typename TYPE> operator TYPE*() const {
        return (TYPE*) m_data.second->
          cast.apply_dynCast(ComponentCast::instance<TYPE>(),m_data.first);
        //cast.apply_downCast(ComponentCast::instance<TYPE>(),m_data.first);
      }
    };


    class Geant4HitCollection : public G4VHitsCollection {
    public:
      typedef std::vector<Geant4HitWrapper>    WrappedHits;
      typedef Geant4HitWrapper::HitManipulator Manip;
      typedef std::map<VolumeID, size_t>  Keys;


      class Compare {
      public:
        virtual ~Compare();
        virtual void* operator()(const Geant4HitWrapper& w) const = 0;
      };

      union CollectionFlags  {
        unsigned long        value;
        struct BitItems  {
          unsigned           repeatedLookup:1;
          unsigned           mappedLookup:1;
        }                    bits;
      };

    protected:
      WrappedHits                      m_hits;
      Geant4Sensitive*                 m_detector;
      Manip*                           m_manipulator;
      size_t                           m_lastHit;
      Keys                             m_keys;
      CollectionFlags                  m_flags;
      
    protected:
      void newInstance();
      void* findHit(const Compare& cmp);
      Geant4HitWrapper* findHitByKey(VolumeID key);
      void releaseData(const ComponentCast& cast, std::vector<void*>* result);
      void getData(const ComponentCast& cast, std::vector<void*>* result);

    public:
      enum {
        OPTIMIZE_NONE = 0,
        OPTIMIZE_REPEATEDLOOKUP = 1<<0,
        OPTIMIZE_MAPPEDLOOKUP   = 1<<1,
        OPTIMIZE_LAST
      } OptimizationFlags;

      template <typename TYPE>
      Geant4HitCollection(const std::string& det, const std::string& coll, Geant4Sensitive* sd)
        : G4VHitsCollection(det, coll), m_detector(sd),
          m_manipulator(Geant4HitWrapper::manipulator<TYPE>()),
          m_lastHit(ULONG_MAX)
      {
        newInstance();
        m_hits.reserve(200);
        m_flags.value = OPTIMIZE_REPEATEDLOOKUP;
      }
      template <typename TYPE>
      Geant4HitCollection(const std::string& det, const std::string& coll, Geant4Sensitive* sd, const TYPE*)
        : G4VHitsCollection(det, coll), m_detector(sd),
          m_manipulator(Geant4HitWrapper::manipulator<TYPE>()),
          m_lastHit(ULONG_MAX)
      {
        newInstance();
        m_hits.reserve(200);
        m_flags.value = 0;//OPTIMIZE_REPEATEDLOOKUP;
      }
      virtual ~Geant4HitCollection();
      const ComponentCast& type() const;
      const ComponentCast& vector_type() const;
      virtual void clear();
      void setOptimize(int flag)  {
        m_flags.value |= flag;
      }
      void setSensitive(Geant4Sensitive* detector)   {
        m_detector = detector;
      }
      Geant4Sensitive* sensitive() const   {
        return m_detector;
      }
      virtual G4VHit* GetHit(size_t which) const {
        return (G4VHit*) &m_hits.at(which);
      }
      virtual size_t GetSize() const {
        return m_hits.size();
      }
      Geant4HitWrapper& hit(size_t which) {
        return m_hits.at(which);
      }
      const Geant4HitWrapper& hit(size_t which) const {
        return m_hits.at(which);
      }
      template <typename TYPE> void add(TYPE* hit_pointer) {
        Geant4HitWrapper w(m_manipulator->castHit(hit_pointer));
        m_lastHit = m_hits.size();
        m_hits.push_back(w);
      }
      template <typename TYPE> void add(VolumeID key, TYPE* hit_pointer) {
        m_lastHit = m_hits.size();
        std::pair<Keys::iterator,bool> ret = m_keys.insert(std::make_pair(key,m_lastHit));
        if ( ret.second )  {
          Geant4HitWrapper w(m_manipulator->castHit(hit_pointer));
          m_hits.push_back(w);
          return;
        }
        throw std::runtime_error("Attempt to insert hit with same key to G4 hit-collection "+GetName());
      }
      template <typename TYPE> TYPE* find(const Compare& cmp) {
        return (TYPE*) findHit(cmp);
      }
      template <typename TYPE> TYPE* findByKey(VolumeID key) {
        Keys::const_iterator i=m_keys.find(key);
        if ( i == m_keys.end() ) return 0;
        m_lastHit = (*i).second;
        TYPE* obj = m_hits.at(m_lastHit);
        return obj;
      }
      template <typename TYPE> std::vector<TYPE*> releaseHits() {
        std::vector<TYPE*> vec;
        if (m_hits.size() != 0) {
          releaseData(ComponentCast::instance<TYPE>(), (std::vector<void*>*) &vec);
        }
        m_lastHit = ULONG_MAX;
        m_keys.clear();
        return vec;
      }
      void releaseHitsUnchecked(std::vector<void*>& result);

      template <typename TYPE> std::vector<TYPE*> getHits() {
        std::vector<TYPE*> vec;
        if (m_hits.size() != 0) {
          getData(ComponentCast::instance<TYPE>(), (std::vector<void*>*) &vec);
        }
        return vec;
      }
      void getHitsUnchecked(std::vector<void*>& result);
    };



    template<typename TYPE, typename POS> class PositionCompare : public Geant4HitCollection::Compare {
    public:
      const POS& pos;
      PositionCompare(const POS& p) : pos(p)  {      }
      virtual void* operator()(const Geant4HitWrapper& w) const;
    };

    template <typename TYPE, typename POS>
    void* PositionCompare<TYPE,POS>::operator()(const Geant4HitWrapper& w) const {
      TYPE* h = w;
      return pos == h->position ? h : 0;
    }


    template<typename TYPE> class CellIDCompare : public Geant4HitCollection::Compare {
    public:
      long long int id;
      CellIDCompare(long long int i) : id(i) {      }
      virtual void* operator()(const Geant4HitWrapper& w) const;
    };

    template <typename TYPE>
    void* CellIDCompare<TYPE>::operator()(const Geant4HitWrapper& w) const {
      TYPE* h = w;
      if ( id == h->cellID )
        return h;
      return 0;
    }

  }    // End namespace Simulation
}      // End namespace DD4hep

#endif // DD4HEP_DDG4_GEANT4HITCOLLECTION_H