Geant4Kernel.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_GEANT4KERNEL_H
#define DDG4_GEANT4KERNEL_H
 
// Framework include files
#include <DDG4/Geant4ActionContainer.h>
 
// C/C++ include files
#include <map>
#include <typeinfo>
#include <functional>
 
// Forward declarations
class G4RunManager;
class G4UIdirectory;
class G4VPhysicalVolume;
 
namespace dd4hep {
 
  // Forward declarations
  class Geant4Interrupts;
 
  namespace sim {
 
    // Forward declarations
    class Geant4Interrupts;
    class Geant4ActionPhase;
 
    class DD4hep_End_Of_File : public std::exception {
    public:
      DD4hep_End_Of_File() : std::exception() {}
      virtual const char* what() const noexcept override { return "Reached end of input file"; }
    };
 
    class DD4hep_Stop_Processing : public std::exception {
    public:
      DD4hep_Stop_Processing() : std::exception() {}
      virtual const char* what() const noexcept override { return "Event loop STOP signalled. Processing stops"; }
    };
 
 
    class Geant4Kernel : public Geant4ActionContainer  {
    public:
      typedef std::map<unsigned long, Geant4Kernel*>    Workers;
      typedef std::map<std::string, Geant4ActionPhase*> Phases;
      typedef std::map<std::string, Geant4Action*>      GlobalActions;
      typedef std::map<std::string,int>                 ClientOutputLevels;
      typedef std::pair<void*, const std::type_info*>   UserFramework;
      using UserCallbacks = std::vector<std::function<void()> >;
 
      enum event_loop_status  {
        EVENTLOOP_HALT = 0,
        EVENTLOOP_RUNNING = 1,
      };
      
    protected:
      G4RunManager*      m_runManager  { nullptr };
      G4UIdirectory*     m_control     { nullptr };
      G4TrackingManager* m_trackMgr    { nullptr };
      Detector*          m_detDesc     { nullptr };
      PropertyManager    m_properties          { };
      UserFramework      m_userFramework       { };
 
      Phases        m_phases                   { };
      Workers       m_workers                  { };
      GlobalActions m_globalActions            { };
      GlobalActions m_globalFilters            { };
      ClientOutputLevels m_clientLevels        { };
      std::string   m_controlName              { };
      std::string   m_uiName                   { };
      std::string   m_runManagerType;
      std::string   m_dfltSensitiveDetectorType;
      std::map<std::string, std::string> m_sensitiveDetectorTypes;
      long          m_numEvent       = 10;
      int           m_outputLevel    = 0;
 
      int           m_numThreads     = 0;
      int           m_haveScoringMgr = false;
      int           m_processEvents  = EVENTLOOP_RUNNING;
 
      
      UserCallbacks m_actionConfigure  { };
      UserCallbacks m_actionInitialize { };
      UserCallbacks m_actionTerminate  { };
 
 
      unsigned long      m_id = 0, m_ident = 0;
      G4VPhysicalVolume* m_world  = 0;
 
      Geant4Kernel*      m_master         { nullptr };
      Geant4Interrupts*  m_interrupts     { nullptr };
 
      bool isMaster() const  { return this == m_master; }
      bool isWorker() const  { return this != m_master; }
 
#ifndef __CINT__
      Geant4Kernel(Geant4Kernel* m, unsigned long identifier);
#endif
 
    public:
      Geant4Kernel(Detector& description);
 
      Geant4Kernel& master()  const  { return *m_master; }
 
      //bool isMultiThreaded() const { return m_multiThreaded; }
      bool isMultiThreaded() const { return m_numThreads > 0; }
      int numThreads()       const { return m_numThreads; }
 
      static unsigned long int thread_self();
 
    public:
 
 
      class PhaseSelector {
      public:
        Geant4Kernel* m_kernel;
        PhaseSelector(Geant4Kernel* kernel);
        PhaseSelector(const PhaseSelector& c);
        PhaseSelector& operator=(const PhaseSelector& c);
        Geant4ActionPhase& operator[](const std::string& name) const;
      } phase;
 
      enum State {
        SETTING_UP, INITIALIZED
      };
      virtual ~Geant4Kernel();
 
#ifndef __CINT__
      static Geant4Kernel& instance(Detector& description);
#endif
      const Phases& phases() const              {        return m_phases;          }
      Detector& detectorDescription() const     {        return *m_detDesc;        }
      G4TrackingManager* trackMgr() const       {        return m_trackMgr;        }
      void setTrackMgr(G4TrackingManager* mgr)  {        m_trackMgr = mgr;         }
      const std::string& directoryName() const  {        return m_controlName;     }
      unsigned long id()  const                 {        return m_ident;           }
      G4RunManager& runManager();
      UserFramework& userFramework()            {        return m_userFramework;   }
      template <typename T> void setUserFramework(T* object)   {
        m_userFramework = UserFramework(object,&typeid(T));
      }
      const std::string defaultSensitiveDetectorType()  const  {
        return m_dfltSensitiveDetectorType;
      }
      const std::map<std::string, std::string>& sensitiveDetectorTypes()  const   {
        return m_sensitiveDetectorTypes;
      }
 
      void defineSensitiveDetectorType(const std::string& type, const std::string& factory);
      G4VPhysicalVolume* world()  const;
      void setWorld(G4VPhysicalVolume* volume);
      
      PropertyManager& properties()             {        return m_properties;      }
      void printProperties() const;
      template <typename T> Geant4Kernel& declareProperty(const std::string& nam, T& val);
      template <typename T> Geant4Kernel& declareProperty(const char* nam, T& val);
      bool hasProperty(const std::string& name) const;
      Property& property(const std::string& name);
 
      PrintLevel outputLevel() const  {        return (PrintLevel)m_outputLevel;    }
      PrintLevel setOutputLevel(PrintLevel new_level);
      void setOutputLevel(const std::string object, PrintLevel new_level);
      PrintLevel getOutputLevel(const std::string object) const;
 
      void register_configure(const std::function<void()>& callback);
      void register_initialize(const std::function<void()>& callback);
      void register_terminate(const std::function<void()>& callback);
 
      Geant4Interrupts& interruptHandler()  const;
      void triggerStop();
      bool processEvents()  const;
      bool registerInterruptHandler(int sig_num);
 
      void applyInterruptHandlers();
      
 
      Geant4Kernel& registerGlobalAction(Geant4Action* action);
      Geant4Action* globalAction(const std::string& action_name, bool throw_if_not_present = true);
 
      Geant4Kernel& registerGlobalFilter(Geant4Action* filter);
      Geant4Action* globalFilter(const std::string& filter_name, bool throw_if_not_present = true);
 
      Geant4ActionPhase* getPhase(const std::string& name);
 
      virtual Geant4ActionPhase* addSimplePhase(const std::string& name, bool throw_on_exist);
 
      virtual Geant4ActionPhase* addPhase(const std::string& name, const std::type_info& arg1, const std::type_info& arg2,
                                          const std::type_info& arg3, bool throw_on_exist);
      template <typename A0> Geant4ActionPhase* addPhase(const std::string& name, bool throw_on_exist = true) {
        return addPhase(name, typeid(A0), typeid(void), typeid(void), throw_on_exist);
      }
      template <typename A0, typename A1>
      Geant4ActionPhase* addPhase(const std::string& name, bool throw_on_exist = true) {
        return addPhase(name, typeid(A0), typeid(A1), typeid(void), throw_on_exist);
      }
      template <typename A0, typename A1, typename A2>
      Geant4ActionPhase* addPhase(const std::string& name, bool throw_on_exist = true) {
        return addPhase(name, typeid(A0), typeid(A1), typeid(A2), throw_on_exist);
      }
      virtual bool removePhase(const std::string& name);
      virtual void destroyPhases();
 
      virtual bool executePhase(const std::string& name, const void** args)  const;
 
      virtual void loadGeometry(const std::string& compact_file);
      virtual void loadXML(const char* fname);
      virtual long runPlugin(const std::string& plgin, const std::vector<std::string>& args);
 
      virtual Geant4Kernel& createWorker();
      Geant4Kernel& worker(unsigned long thread_identifier, bool create_if=false);
      int numWorkers() const;
 
      virtual int configure();
      virtual int initialize();
      virtual int run();
      virtual int runEvents(int num_events);
      virtual int terminate()  override;
    };
    template <typename T> Geant4Kernel& Geant4Kernel::declareProperty(const std::string& nam, T& val) {
      m_properties.add(nam, val);
      return *this;
    }
 
    template <typename T> Geant4Kernel& Geant4Kernel::declareProperty(const char* nam, T& val) {
      m_properties.add(nam, val);
      return *this;
    }
 
    class Geant4Exec {
    public:
      static int configure(Geant4Kernel& kernel);
      static int initialize(Geant4Kernel& kernel);
      static int run(Geant4Kernel& kernel);
      static int terminate(Geant4Kernel& kernel);
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
#endif // DDG4_GEANT4KERNEL_H