Geant4Action.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_GEANT4ACTION_H
#define DDG4_GEANT4ACTION_H
 
// Framework include files
#include <DD4hep/Printout.h>
#include <DD4hep/ComponentProperties.h>
#include <DDG4/Geant4Context.h>
#include <DDG4/Geant4Callback.h>
 
// Geant4 forward declarations
class G4Run;
class G4Event;
class G4Step;
class G4Track;
class G4TrackStack;
class G4EventGenerator;
class G4VTrajectory;
class G4TrackingManager;
class G4UIdirectory;
 
// C/C++ include files
#include <string>
#include <cstdarg>
 
#if defined(G__ROOT) || defined(__CLING__) || defined(__ROOTCLING__)
#define DDG4_DEFINE_ACTION_DEFAULT_CTOR(action)  public: action() = default;
#else
#define DDG4_DEFINE_ACTION_DEFAULT_CTOR(action)  protected: action() = delete;
#endif
 
#define DDG4_DEFINE_ACTION_CONSTRUCTORS(action)  \
  DDG4_DEFINE_ACTION_DEFAULT_CTOR(action)        \
  protected:                                     \
  action(action&& copy) = delete;                \
  action(const action& copy) = delete;           \
  action& operator=(action&& copy) = delete;     \
  action& operator=(const action& copy) = delete
 
 
namespace dd4hep {
 
  namespace sim {
 
    // Forward declarations
    class Geant4UIMessenger;
 
    template <typename TO, typename FROM> TO fast_cast(FROM from) {
#ifdef USE_FASTCAST
      return static_cast<TO>(from);
#else
      return dynamic_cast<TO>(from);
#endif
    }
 
 
    class TypeName {
    public:
      std::string first;
      std::string second;
      TypeName() = default;
      TypeName(const TypeName& copy) = default;
      TypeName(const std::pair<std::string, std::string>& c)
        : first(c.first), second(c.second) { }
      TypeName(const std::string& typ, const std::string& nam)
        : first(typ), second(nam) { }
      TypeName& operator=(const TypeName& copy) = default;
      static TypeName split(const std::string& type_name);
      static TypeName split(const std::string& type_name, const std::string& delim);
    };
 
 
    class Geant4Action {
    protected:
      Geant4Context*     m_context      { nullptr };
      Geant4UIMessenger* m_control      { nullptr };
 
      int                m_outputLevel  { 3 };
      bool               m_needsControl { false };
      std::string        m_name         {   };
      PropertyManager    m_properties   {   };
      long               m_refCount     { 1 };
 
    public:
 
      class ContextSwap   {
        Geant4Context* context { nullptr };
        Geant4Action*  action  { nullptr };
      public:
        ContextSwap(Geant4Action* a,Geant4Context* c) : action(a)  {
          context = action->context();
          action->updateContext(c);
        }
        ~ContextSwap()  { 
          action->updateContext(context);
        }
      };
 
    protected:
 
      struct FindByName  {
        std::string _n;
        FindByName(const std::string& n) : _n(n) {}
        bool operator()(const Geant4Action* a) { return a->name() == _n; }
      };
 
      template <typename T> class Actors {
      public:
        typedef typename std::vector<T*> _V;
        _V m_v;
        Actors() = default;
        ~Actors()  = default;
        void clear()                  { m_v.clear();                    }
        void add(T* obj)              { m_v.emplace_back(obj);          }
        void add_front(T* obj)        { m_v.insert(m_v.begin(), obj);   }
        operator const _V&() const    { return m_v;                     }
        operator _V&()                { return m_v;                     }
        const _V* operator->() const  { return &m_v;                    }
        _V* operator->()              { return &m_v;                    }
        typename _V::iterator begin() { return m_v.begin();             }
        typename _V::iterator end()   { return m_v.end();               }
        typename _V::const_iterator begin() const { return m_v.begin(); }
        typename _V::const_iterator end()   const { return m_v.end();   }
        
        void updateContext(Geant4Context* ctxt)  {
          (*this)(&T::updateContext,ctxt);
        }
        template <typename F> typename _V::value_type get(const F& f)  const   {
          if (!m_v.empty())  {
            typename _V::const_iterator i=std::find_if(m_v.begin(),m_v.end(),f);
            return i==m_v.end() ? 0 : (*i);
          }
          return 0;
        }
        template <typename R, typename Q> void operator()(R (Q::*pmf)()) {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          (o->*pmf)();
        }
        template <typename R, typename Q, typename A0> void operator()(R (Q::*pmf)(A0), A0 a0) {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          (o->*pmf)(a0);
        }
        template <typename R, typename Q, typename A0, typename A1> void operator()(R (Q::*pmf)(A0, A1), A0 a0, A1 a1) {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          (o->*pmf)(a0, a1);
        }
        template <typename R, typename Q> void operator()(R (Q::*pmf)() const) const {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          (o->*pmf)();
        }
        template <typename R, typename Q, typename A0> void operator()(R (Q::*pmf)(A0) const, A0 a0) const {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          (o->*pmf)(a0);
        }
        template <typename R, typename Q, typename A0, typename A1> void operator()(R (Q::*pmf)(A0, A1) const, A0 a0, A1 a1) const {
      if ( !m_v.empty() )
        for (const auto& o : m_v)
          (o->*pmf)(a0, a1);
        }
        template <typename Q> bool filter(bool (Q::*pmf)() const) const {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          if ( !(o->*pmf)() )
        return false;
          return true;
        }
        template <typename Q, typename A0> bool filter(bool (Q::*pmf)(A0) const, A0 a0) const {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          if ( !(o->*pmf)(a0) )
        return false;
          return true;
        }
        template <typename Q, typename A0, typename A1> bool filter(bool (Q::*pmf)(A0, A1) const, A0 a0, A1 a1) const {
          if ( !m_v.empty() )
        for (const auto& o : m_v)
          if ( !(o->*pmf)(a0,a1) )
        return false;
          return true;
        }
      };
 
    protected:
      
      DDG4_DEFINE_ACTION_CONSTRUCTORS(Geant4Action);
 
      virtual ~Geant4Action();
 
    public:
      Geant4Action(Geant4Context* context, const std::string& nam);
      long addRef();
      long release();
      Geant4Context* context()  const {
        return m_context;
      }
      virtual void updateContext(Geant4Context* ctxt)  {
        m_context = ctxt; 
      }
      virtual void configureFiber(Geant4Context* thread_context);
      const std::string& name() const {
        return m_name;
      }
      const char* c_name() const {
        return m_name.c_str();
      }
      void setName(const std::string& new_name) {
        m_name = new_name;
      }
      PropertyManager& properties() {
        return m_properties;
      }
      PrintLevel outputLevel() const  {
        return (PrintLevel)m_outputLevel;
      }
      PrintLevel setOutputLevel(PrintLevel new_level);
      Geant4UIMessenger* control() const;
      virtual void enableUI();
      template <typename T> Geant4Action& declareProperty(const std::string& nam, T& val);
      template <typename T> Geant4Action& declareProperty(const char* nam, T& val);
      bool hasProperty(const std::string& name) const;
      Property& property(const std::string& name);
      virtual void installMessengers();
      virtual void installCommandMessenger();
      virtual void installPropertyMessenger();
 
      void print(const char* fmt, ...) const;
      void printM1(const char* fmt, ...) const;
      void printM2(const char* fmt, ...) const;
      void printP1(const char* fmt, ...) const;
      void printP2(const char* fmt, ...) const;
 
      void always(const char* fmt, ...) const;
      void debug(const char* fmt, ...) const;
      void info(const char* fmt, ...) const;
      void warning(const char* fmt, ...) const;
      void error(const char* fmt, ...) const;
      bool return_error(bool return_value, const char* fmt, ...) const;
      void fatal(const char* fmt, ...) const;
      void except(const char* fmt, ...) const;
 
      void abortRun(const std::string& exception, const char* fmt, ...) const;
 
      Geant4RunActionSequence& runAction() const;
      Geant4EventActionSequence& eventAction() const;
      Geant4SteppingActionSequence& steppingAction() const;
      Geant4TrackingActionSequence& trackingAction() const;
      Geant4StackingActionSequence& stackingAction() const;
      Geant4GeneratorActionSequence& generatorAction() const;
    };
 
    template <typename T> Geant4Action& Geant4Action::declareProperty(const std::string& nam, T& val) {
      m_properties.add(nam, val);
      return *this;
    }
 
    template <typename T> Geant4Action& Geant4Action::declareProperty(const char* nam, T& val) {
      m_properties.add(nam, val);
      return *this;
    }
  }    // End namespace sim
}      // End namespace dd4hep
 
#endif // DDG4_GEANT4ACTION_H