Geant4Kernel.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_GEANT4KERNEL_H
#define DD4HEP_DDG4_GEANT4KERNEL_H

// Framework include files
#include "DDG4/Geant4ActionContainer.h"

// C/C++ include files
#include <map>
#include <typeinfo>

// Forward declarations
class G4RunManager;
class G4UIdirectory;

namespace DD4hep {

  namespace Simulation {

    // Forward declarations
    class Geant4ActionPhase;


    class Geant4Kernel : public Geant4ActionContainer  {
    public:
      typedef DD4hep::Geometry::LCDD LCDD;
      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;

    protected:
      G4RunManager*      m_runManager;
      G4UIdirectory*     m_control;
      G4TrackingManager* m_trackMgr;
      LCDD*              m_lcdd;
      PropertyManager    m_properties;


      Phases        m_phases;
      Workers       m_workers;
      GlobalActions m_globalActions;
      GlobalActions m_globalFilters;
      std::string m_controlName;
      std::string m_uiName;
      long        m_numEvent;
      int         m_outputLevel;
      ClientOutputLevels m_clientLevels;

      //bool        m_multiThreaded;
      int         m_numThreads;
      unsigned long      m_id, m_ident;
      Geant4Kernel*      m_master;
      Geant4Kernel*      m_shared;
      Geant4Context*     m_threadContext;

      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(LCDD& lcdd);

      Geant4Kernel& master()  const  { return *m_master; }

      Geant4Kernel& shared()  const  { return *m_shared; }

      //bool isMultiThreaded() const { return m_multiThreaded; }
      bool isMultiThreaded() const { return m_numThreads > 0; }

      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(LCDD& lcdd);
#endif
      const Phases& phases() const              {        return m_phases;          }
      LCDD& lcdd() const                        {        return *m_lcdd;           }
      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();

      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;


      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 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();
    };
    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 Simulation
}      // End namespace DD4hep
#endif // DD4HEP_DDG4_GEANT4KERNEL_H