Geant4Action.h

Go to the documentation of this file.

//==========================================================================
//  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_GEANT4ACTION_H
#define DD4HEP_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>

namespace DD4hep {

  namespace Simulation {

    // 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::pair<std::string, std::string> {
    public:
      TypeName() = default;
      TypeName(const TypeName& copy) = default;
      TypeName(const std::pair<std::string, std::string>& c)
        : std::pair<std::string, std::string>(c) {      }
      TypeName(const std::string& typ, const std::string& nam)
        : std::pair<std::string, std::string>(typ, 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 = 0;
      Geant4UIMessenger* m_control = 0;

      int                m_outputLevel = 3;
      bool               m_needsControl = false;
      std::string        m_name;
      PropertyManager    m_properties;
      long               m_refCount = 1;

    public:

      class ContextSwap   {
        Geant4Context* context = 0;
        Geant4Action*  action = 0;
      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.push_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())
            return;
          for (typename _V::iterator i = m_v.begin(); i != m_v.end(); ++i)
            ((*i)->*pmf)();
        }
        template <typename R, typename Q, typename A0> void operator()(R (Q::*pmf)(A0), A0 a0) {
          if (m_v.empty())
            return;
          for (typename _V::iterator i = m_v.begin(); i != m_v.end(); ++i)
            ((*i)->*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())
            return;
          for (typename _V::iterator i = m_v.begin(); i != m_v.end(); ++i)
            ((*i)->*pmf)(a0, a1);
        }
        template <typename R, typename Q> void operator()(R (Q::*pmf)() const) const {
          if (m_v.empty())
            return;
          for (typename _V::const_iterator i = m_v.begin(); i != m_v.end(); ++i)
            ((*i)->*pmf)();
        }
        template <typename R, typename Q, typename A0> void operator()(R (Q::*pmf)(A0) const, A0 a0) const {
          if (m_v.empty())
            return;
          for (typename _V::const_iterator i = m_v.begin(); i != m_v.end(); ++i)
            ((*i)->*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())
            return;
          for (typename _V::const_iterator i = m_v.begin(); i != m_v.end(); ++i)
            ((*i)->*pmf)(a0, a1);
        }
        template <typename Q> bool filter(bool (Q::*pmf)() const) const {
          if (!m_v.empty())
            return true;
          for (typename _V::const_iterator i = m_v.begin(); i != m_v.end(); ++i)
            if (!((*i)->*pmf)())
              return false;
          return true;
        }
        template <typename Q, typename A0> bool filter(bool (Q::*pmf)(A0) const, A0 a0) const {
          if (m_v.empty())
            return true;
          for (typename _V::const_iterator i = m_v.begin(); i != m_v.end(); ++i)
            if (!((*i)->*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())
            return true;
          for (typename _V::const_iterator i = m_v.begin(); i != m_v.end(); ++i)
            if (!((*i)->*pmf)(a0, a1))
              return false;
          return true;
        }
      };

    protected:
      Geant4Action() = default;
      Geant4Action(const Geant4Action& copy) = delete;
      Geant4Action& operator=(const Geant4Action& copy) = delete;

      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);
      Geant4Action& setProperties(PropertyConfigurator& setup);

      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 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 Simulation
}      // End namespace DD4hep

#endif // DD4HEP_DDG4_GEANT4ACTION_H