Geant4Handle.cpp

//==========================================================================
//  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
//
//==========================================================================

// Framework include files
#include <DD4hep/Detector.h>
#include <DD4hep/Plugins.h>
#include <DD4hep/Printout.h>

#include <DDG4/Geant4Handle.h>
#include <DDG4/Geant4Kernel.h>
#include <DDG4/Geant4GeneratorAction.h>
#include <DDG4/Geant4RunAction.h>
#include <DDG4/Geant4EventAction.h>
#include <DDG4/Geant4TrackingAction.h>
#include <DDG4/Geant4SteppingAction.h>
#include <DDG4/Geant4StackingAction.h>
#include <DDG4/Geant4SensDetAction.h>
#include <DDG4/Geant4PhysicsList.h>
#include <DDG4/Geant4ActionPhase.h>
#include <DDG4/Geant4UserInitialization.h>
#include <DDG4/Geant4DetectorConstruction.h>

// Geant4 include files
#include <G4Threading.hh>
#include <G4AutoLock.hh>

using namespace dd4hep::sim;
namespace {
  G4Mutex creation_mutex=G4MUTEX_INITIALIZER;
}

namespace dd4hep {
  namespace sim {

    template <typename TYPE> static inline TYPE* checked_value(TYPE* p) {
      if (p) {
        return p;
      }
      except("Geant4Handle","Attempt to access an invalid object of type:%s!",
             typeName(typeid(TYPE)).c_str());
      return 0;
    }

    template <typename TYPE> Geant4Handle<TYPE>::Geant4Handle(TYPE* typ) : value(typ)  {
      if (value)
        value->addRef();
    }

    template <typename TYPE> Geant4Handle<TYPE>::Geant4Handle(const Geant4Handle<TYPE>& handle) : value(handle.get())
    {
      if (value)
        value->addRef();
    }

    template <typename TYPE> Geant4Handle<TYPE>::Geant4Handle(Geant4Handle<TYPE>&& handle) : value(handle.get())
    {
      handle.value = 0;
    }

    template <typename TYPE> TYPE* _create_object(Geant4Kernel& kernel, const TypeName& typ)    {
      Geant4Context* ctxt = kernel.workerContext();
      Geant4Action* object = PluginService::Create<Geant4Action*>(typ.first, ctxt, typ.second);
      if (!object && typ.first == typ.second) {
        std::string _t = typeName(typeid(TYPE));
        printout(DEBUG, "Geant4Handle", "Object factory for %s not found. Try out %s",
                 typ.second.c_str(), _t.c_str());
        object = PluginService::Create<Geant4Action*>(_t, ctxt, typ.second);
        if (!object) {
          size_t idx = _t.rfind(':');
          if (idx != std::string::npos)
            _t = std::string(_t.substr(idx + 1));
          printout(DEBUG, "Geant4Handle", "Try out object factory for %s",_t.c_str());
          object = PluginService::Create<Geant4Action*>(_t, ctxt, typ.second);
        }
      }
      if (object)  {
        TYPE* ptr = dynamic_cast<TYPE*>(object);
        if (ptr)  {
          return ptr;
        }
        std::string _t = typeName(typeid(TYPE));
        except("Geant4Handle", "Failed to convert object of type '%s' with name '%s' to handle of type '%s'!",
               typ.first.c_str(),typ.second.c_str(),_t.c_str());
      }
      except("Geant4Handle", "Failed to create object of type %s!", typ.first.c_str());
      return 0;
    }

    template <typename TYPE, typename CONT> 
    TYPE* _create_share(Geant4Kernel& kernel,
                        CONT& (Geant4ActionContainer::*pmf)(), 
                        const std::string& type_name, 
                        const std::string& shared_typ, 
                        bool shared, TYPE*)
    {
      TypeName typ = TypeName::split(type_name);
      Geant4Kernel& k = shared ? kernel.master() : kernel;
      if ( shared && k.isMultiThreaded() )   {
        typedef typename TYPE::shared_type _ST;
        TypeName s_type = TypeName::split(shared_typ+"/"+typ.second);
        _ST* object = (_ST*)_create_object<TYPE>(kernel,s_type);
        CONT& container = (k.*pmf)();
        TYPE* value = 0;
        { // Need to protect the global action sequence!
          G4AutoLock protection_lock(&creation_mutex);
          value = container.get(typ.second);
          if ( !value ) {
            value = _create_object<TYPE>(k,typ);
            container.adopt(value);
            value->release();
          }
        }
        object->use(value);
        value->info("+++ Created shared object for %s of type %s.",
                    typ.second.c_str(),typeName(typeid(TYPE)).c_str());
        return object;
      }
      TYPE* value = _create_object<TYPE>(k,typ);
      return value;
    }

    template <typename TYPE> 
    Geant4Handle<TYPE>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool /* shared */)  {
      value = _create_object<TYPE>(kernel,TypeName::split(type_name));
    }

    template <typename TYPE> 
    Geant4Handle<TYPE>::Geant4Handle(Geant4Kernel& kernel, const char* type_name_char, bool /* shared */)  {
      value = _create_object<TYPE>(kernel,TypeName::split(type_name_char ? type_name_char : "????"));
    }

    template <typename TYPE> Geant4Handle<TYPE>::~Geant4Handle() {
      if (value)
        value->release();
      value = 0;
    }

    template <typename TYPE> TYPE* Geant4Handle<TYPE>::release() {
      TYPE* temp = value;
      value = 0;
      return temp;
    }

    template <typename TYPE> void Geant4Handle<TYPE>::checked_assign(TYPE* p) {
      if (value)
        value->release();
      value = checked_value(p);
      if (value)
        value->addRef();
    }

    template <typename TYPE> Property& Geant4Handle<TYPE>::operator[](const std::string& property_name) const {
      PropertyManager& pm = checked_value(value)->properties();
      return pm[property_name];
    }

    template <typename TYPE> Geant4Handle<TYPE>::operator TYPE*() const {
      return checked_value(value);
    }

    template <typename TYPE> bool Geant4Handle<TYPE>::operator!() const {
      return 0 == value;
    }

    template <typename TYPE> TYPE* Geant4Handle<TYPE>::get() const {
      return checked_value(value);
    }

    template <typename TYPE> TYPE* Geant4Handle<TYPE>::operator->() const {
      return checked_value(value);
    }

    template <typename TYPE> Geant4Action* Geant4Handle<TYPE>::action() const {
      return checked_value(value);
    }

    /// Assignment operator
    template <typename TYPE> Geant4Handle<TYPE>& Geant4Handle<TYPE>::operator=(const Geant4Handle& handle) {
      if ( &handle != this )  {
        TYPE* point = value;
        value = handle.get();
        if ( value ) value->addRef();
        if ( point ) point->release();
      }
      return *this;
    }

    /// Assignment move operator
    template <typename TYPE> Geant4Handle<TYPE>& Geant4Handle<TYPE>::operator=(Geant4Handle&& handle) {
      if ( value ) value->release();
      value = handle.get();
      handle.value = 0;
      return *this;
    }

    template <typename TYPE> Geant4Handle<TYPE>& Geant4Handle<TYPE>::operator=(TYPE* pointer) {
      if ( pointer != value )  {
        TYPE* point = value;
        value = pointer;
        if ( value ) value->addRef();
        if ( point ) point->release();
      }
      return *this;
    }

    //namespace dd4hep {
    //  namespace sim {

    KernelHandle::KernelHandle()  {
      value = &Geant4Kernel::instance(Detector::getInstance());
    }
    KernelHandle::KernelHandle(Geant4Kernel* k) : value(k)  {
    }
    KernelHandle KernelHandle::worker()  {
      Geant4Kernel* k = value ? &value->worker(Geant4Kernel::thread_self()) : 0;
      if ( k ) return KernelHandle(k);
      except("KernelHandle", "Cannot access worker context [Invalid Handle]");
      return KernelHandle(0);
    }
    void KernelHandle::destroy()  {
      if ( value ) delete value;
      value = 0;
    }

    template <> 
    Geant4Handle<Geant4RunAction>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::runAction, type_name,
                            "Geant4SharedRunAction", shared, null());
    }
    template <> 
    Geant4Handle<Geant4RunAction>::Geant4Handle(Geant4Kernel& kernel, const char* type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::runAction, type_name,
                            "Geant4SharedRunAction", shared, null());
    }

    template <> 
    Geant4Handle<Geant4EventAction>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::eventAction, type_name,
                            "Geant4SharedEventAction", shared, null());
    }
    template <> 
    Geant4Handle<Geant4EventAction>::Geant4Handle(Geant4Kernel& kernel, const char* type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::eventAction, type_name,
                            "Geant4SharedEventAction", shared, null());
    }

    template <> 
    Geant4Handle<Geant4GeneratorAction>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::generatorAction, type_name,
                            "Geant4SharedGeneratorAction", shared, null());
    }
    template <> 
    Geant4Handle<Geant4GeneratorAction>::Geant4Handle(Geant4Kernel& kernel, const char* type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::generatorAction, type_name,
                            "Geant4SharedGeneratorAction", shared, null());
    }

    template <> 
    Geant4Handle<Geant4TrackingAction>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::trackingAction, type_name,
                            "Geant4SharedTrackingAction", shared, null());
    }
    template <> 
    Geant4Handle<Geant4TrackingAction>::Geant4Handle(Geant4Kernel& kernel, const char* type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::trackingAction, type_name,
                            "Geant4SharedTrackingAction", shared, null());
    }

    template <> 
    Geant4Handle<Geant4SteppingAction>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::steppingAction, type_name,
                            "Geant4SharedSteppingAction", shared, null());
    }
    template <> 
    Geant4Handle<Geant4SteppingAction>::Geant4Handle(Geant4Kernel& kernel, const char* type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::steppingAction, type_name,
                            "Geant4SharedSteppingAction", shared, null());
    }

    template <> 
    Geant4Handle<Geant4StackingAction>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::stackingAction, type_name,
                            "Geant4SharedStackingAction", shared, null());
    }
    template <> 
    Geant4Handle<Geant4StackingAction>::Geant4Handle(Geant4Kernel& kernel, const char* type_name, bool shared)  {
      value = _create_share(kernel,&Geant4ActionContainer::stackingAction, type_name,
                            "Geant4SharedStackingAction", shared, null());
    }

    template <> Geant4Handle<Geant4Sensitive>::Geant4Handle(Geant4Kernel& kernel, const std::string& type_name,
                                                            const std::string& detector, bool /* shared */) {
      try {
        Geant4Context*  ctxt = kernel.workerContext();
        TypeName         typ = TypeName::split(type_name);
        Detector&        dsc = kernel.detectorDescription();
        DetElement       det = dsc.detector(detector);
        Geant4Sensitive* obj = PluginService::Create<Geant4Sensitive*>(typ.first, ctxt, typ.second, &det, &dsc);
        if ( obj ) {
          value = obj;
          return;
        }
      }
      catch (const std::exception& e) {
        printout(ERROR, "Geant4Handle<Geant4Sensitive>", "Exception: %s", e.what());
      }
      catch (...) {
        printout(ERROR, "Geant4Handle<Geant4Sensitive>", "Exception: Unknown exception");
      }
      except("Geant4Handle<Geant4Sensitive>", 
             "Failed to create sensitive object of type %s for detector %s!",
             type_name.c_str(), detector.c_str());
    }
  

    template class Geant4Handle<Geant4Action>;
    template class Geant4Handle<Geant4Filter>;
    template class Geant4Handle<Geant4Sensitive>;
    template class Geant4Handle<Geant4ActionPhase>;
    template class Geant4Handle<Geant4PhaseAction>;
    template class Geant4Handle<Geant4GeneratorAction>;
    template class Geant4Handle<Geant4RunAction>;
    template class Geant4Handle<Geant4EventAction>;
    template class Geant4Handle<Geant4TrackingAction>;
    template class Geant4Handle<Geant4SteppingAction>;
    template class Geant4Handle<Geant4StackingAction>;
    template class Geant4Handle<Geant4DetectorConstruction>;
    template class Geant4Handle<Geant4PhysicsList>;
    template class Geant4Handle<Geant4UserInitialization>;

    template class Geant4Handle<Geant4GeneratorActionSequence>;
    template class Geant4Handle<Geant4PhysicsListActionSequence>;
    template class Geant4Handle<Geant4RunActionSequence>;
    template class Geant4Handle<Geant4EventActionSequence>;
    template class Geant4Handle<Geant4TrackingActionSequence>;
    template class Geant4Handle<Geant4SteppingActionSequence>;
    template class Geant4Handle<Geant4StackingActionSequence>;
    template class Geant4Handle<Geant4SensDetActionSequence>;
    template class Geant4Handle<Geant4UserInitializationSequence>;
    template class Geant4Handle<Geant4DetectorConstructionSequence>;
  }
}