Geant4Exec.cpp

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
//
//==========================================================================
 
// Framework include files
#include <DD4hep/Printout.h>
#include <DD4hep/Primitives.h>
#include <DD4hep/InstanceCount.h>
#include <DD4hep/Handle.h>
#include <DDG4/Geant4RunAction.h>
#include <DDG4/Geant4EventAction.h>
#include <DDG4/Geant4SteppingAction.h>
#include <DDG4/Geant4TrackingAction.h>
#include <DDG4/Geant4StackingAction.h>
#include <DDG4/Geant4GeneratorAction.h>
#include <DDG4/Geant4UserInitialization.h>
#include <DDG4/Geant4DetectorConstruction.h>
#include <DDG4/Geant4PhysicsList.h>
#include <DDG4/Geant4UIManager.h>
#include <DDG4/Geant4Kernel.h>
#include <DDG4/Geant4Random.h>
 
// Geant4 include files
#include <G4Version.hh>
#include <G4UserRunAction.hh>
#include <G4UserEventAction.hh>
#include <G4UserTrackingAction.hh>
#include <G4UserStackingAction.hh>
#include <G4UserSteppingAction.hh>
#include <G4VUserPhysicsList.hh>
#include <G4VModularPhysicsList.hh>
#include <G4VUserPrimaryGeneratorAction.hh>
#include <G4VUserActionInitialization.hh>
#include <G4VUserDetectorConstruction.hh>
 
// C/C++ include files
#include <memory>
#include <stdexcept>
 
namespace {
  G4Mutex action_mutex=G4MUTEX_INITIALIZER;
}
 
namespace dd4hep {
 
  namespace sim {
 
    class Geant4DetectorConstructionSequence;
    
 
    template <typename T> class SequenceHdl {
    public:
      typedef SequenceHdl<T> Base;
      T* m_sequence;
      mutable Geant4Context* m_activeContext;
      SequenceHdl()
        : m_sequence(0), m_activeContext(0) {
      }
      SequenceHdl(Geant4Context* ctxt, T* seq) : m_sequence(0), m_activeContext(ctxt)  {
        _aquire(seq);
      }
      virtual ~SequenceHdl() {
        _release();
      }
      void _aquire(T* s) {
        InstanceCount::increment(this);
        m_sequence = s;
        if ( m_sequence ) m_sequence->addRef();
      }
      void _release() {
        detail::releasePtr(m_sequence);
        InstanceCount::decrement(this);
      }
      void updateContext(Geant4Context* ctxt)   {
        m_activeContext = ctxt;
        if ( m_sequence )  {
          m_sequence->updateContext(ctxt);
        }
      }
      Geant4Context* context() const  {  
        return m_activeContext;
      }
      Geant4Kernel& kernel()  const  {
        return context()->kernel();
      }
      void configureFiber(Geant4Context* ctxt)   {
        if ( m_sequence )  {
          m_sequence->configureFiber(ctxt);
        }
      }
      void createClientContext(const G4Run* run)   {
        Geant4Run* r = new Geant4Run(run);
        m_activeContext->setRun(r);
      }
      void destroyClientContext(const G4Run*)   {
        Geant4Run* r = m_activeContext->runPtr();
        if ( r )  {
          m_activeContext->setRun(0);
          detail::deletePtr(r);
        }
      }
      void createClientContext(const G4Event* evt)   {
        Geant4Event* e = new Geant4Event(evt,Geant4Random::instance());
        m_activeContext->setEvent(e);
      }
      void destroyClientContext(const G4Event*)   {
        Geant4Event* e = m_activeContext->eventPtr();
        if ( e )  {
          m_activeContext->setEvent(0);
          detail::deletePtr(e);
        }
      }
    };
 
    class Geant4UserRunAction;
    class Geant4UserEventAction;
 
 
    class Geant4UserRunAction :
      public G4UserRunAction,
      public SequenceHdl<Geant4RunActionSequence>
    {
    public:
      Geant4UserEventAction* eventAction;
      Geant4UserRunAction(Geant4Context* ctxt, Geant4RunActionSequence* seq)
        : Base(ctxt, seq), eventAction(0)  {
        updateContext(ctxt);
        configureFiber(ctxt);
      }
      virtual ~Geant4UserRunAction() {
      }
      virtual void BeginOfRunAction(const G4Run* run)  final;
      virtual void EndOfRunAction(const G4Run* run)  final;
    };
 
 
    class Geant4UserEventAction :
      public G4UserEventAction, 
      public SequenceHdl<Geant4EventActionSequence>
    {
    public:
      Geant4UserRunAction* runAction;
      Geant4UserEventAction(Geant4Context* ctxt, Geant4EventActionSequence* seq)
        : Base(ctxt, seq), runAction(0)  {
        updateContext(ctxt);
        configureFiber(ctxt);
      }
      virtual ~Geant4UserEventAction() {
      }
      virtual void BeginOfEventAction(const G4Event* evt)  final;
      virtual void EndOfEventAction(const G4Event* evt)  final;
    };
 
 
    class Geant4UserTrackingAction :
      public G4UserTrackingAction,
      public SequenceHdl<Geant4TrackingActionSequence>
    {
    public:
      Geant4UserTrackingAction(Geant4Context* ctxt, Geant4TrackingActionSequence* seq)
        : Base(ctxt, seq) {
        updateContext(ctxt);
        configureFiber(ctxt);
      }
      virtual ~Geant4UserTrackingAction() {
      }
      virtual void PreUserTrackingAction(const G4Track* trk)  final  {
        m_sequence->context()->kernel().setTrackMgr(fpTrackingManager);
        m_sequence->begin(trk);
      }
      virtual void PostUserTrackingAction(const G4Track* trk)   final  {
        m_sequence->end(trk);
        m_sequence->context()->kernel().setTrackMgr(0);
      }
    };
 
 
    class Geant4UserStackingAction :
      public G4UserStackingAction,
      public SequenceHdl<Geant4StackingActionSequence>
    {
    public:
      Geant4UserStackingAction(Geant4Context* ctxt, Geant4StackingActionSequence* seq)
        : Base(ctxt, seq) {
        updateContext(ctxt);
        configureFiber(ctxt);
      }
      virtual ~Geant4UserStackingAction() {
      }
      virtual void NewStage()  override final  {
        m_sequence->newStage(stackManager);
      }
      virtual void PrepareNewEvent() override final  {
        m_sequence->prepare(stackManager);
      }
      virtual G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track* track)  override final {
    auto ret = m_sequence->classifyNewTrack(stackManager, track);
    if ( ret.type != NoTrackClassification )
      return ret.value;
    return this->G4UserStackingAction::ClassifyNewTrack(track);
      }
    };
 
 
 
    class Geant4UserGeneratorAction : 
      public G4VUserPrimaryGeneratorAction,
      public SequenceHdl<Geant4GeneratorActionSequence> 
    {
    public:
      Geant4UserGeneratorAction(Geant4Context* ctxt, Geant4GeneratorActionSequence* seq)
        : G4VUserPrimaryGeneratorAction(), Base(ctxt, seq) {
        updateContext(ctxt);
        configureFiber(ctxt);
      }
      virtual ~Geant4UserGeneratorAction() {
      }
      virtual void GeneratePrimaries(G4Event* event)  final;
    };
 
 
    class Geant4UserSteppingAction :
      public G4UserSteppingAction,
      public SequenceHdl<Geant4SteppingActionSequence>
    {
    public:
      Geant4UserSteppingAction(Geant4Context* ctxt, Geant4SteppingActionSequence* seq)
        : Base(ctxt, seq) {
        updateContext(ctxt);
        configureFiber(ctxt);
      }
      virtual ~Geant4UserSteppingAction() {
      }
      virtual void UserSteppingAction(const G4Step* s)   final  {
        (*m_sequence)(s, fpSteppingManager);
      }
    };
 
 
    class Geant4UserDetectorConstruction : 
      public G4VUserDetectorConstruction, 
      public SequenceHdl<Geant4DetectorConstructionSequence>
    {
    protected:
      Geant4DetectorConstructionContext m_ctxt;
    public:
      Geant4UserDetectorConstruction(Geant4Context* ctxt, Geant4DetectorConstructionSequence* seq)
        : G4VUserDetectorConstruction(), Base(ctxt, seq), 
          m_ctxt(ctxt->kernel().detectorDescription(), this) 
      {
      }
      virtual ~Geant4UserDetectorConstruction() {
      }
      virtual void ConstructSDandField()  final;
      virtual G4VPhysicalVolume* Construct()  final;
    };
 
 
    class Geant4UserActionInitialization : 
      public G4VUserActionInitialization, 
      public SequenceHdl<Geant4UserInitializationSequence>
    {
    public:
      Geant4UserActionInitialization(Geant4Context* ctxt, Geant4UserInitializationSequence* seq)
        : G4VUserActionInitialization(), Base(ctxt, seq) {
      }
      virtual ~Geant4UserActionInitialization()  {
      }
      virtual void Build()  const  final;
      virtual void BuildForMaster()  const  final;
    };
 
    void Geant4UserRunAction::BeginOfRunAction(const G4Run* run) {
      createClientContext(run);
      kernel().executePhase("begin-run",(const void**)&run);
      if ( m_sequence ) m_sequence->begin(run); // Action not mandatory
      kernel().applyInterruptHandlers();
    }
 
    void Geant4UserRunAction::EndOfRunAction(const G4Run* run) {
      if ( m_sequence ) m_sequence->end(run); // Action not mandatory
      kernel().executePhase("end-run",(const void**)&run);
      destroyClientContext(run);
    }
 
    void Geant4UserEventAction::BeginOfEventAction(const G4Event* evt) {
      kernel().executePhase("begin-event",(const void**)&evt);
      if ( m_sequence ) m_sequence->begin(evt); // Action not mandatory
    }
 
    void Geant4UserEventAction::EndOfEventAction(const G4Event* evt) {
      if ( m_sequence ) m_sequence->end(evt); // Action not mandatory
      kernel().executePhase("end-event",(const void**)&evt);
      destroyClientContext(evt);
    }
 
    void Geant4UserGeneratorAction::GeneratePrimaries(G4Event* event) {
      createClientContext(event);
      if ( m_sequence )  {
        (*m_sequence)(event);
        return;
      }
      throw std::runtime_error("GeneratePrimaries: Panic! No action sequencer defined. "
                               "No primary particles can be produced.");
    }
 
    void Geant4UserDetectorConstruction::ConstructSDandField()  {
      G4AutoLock protection_lock(&action_mutex);
      Geant4Context* ctx = m_sequence->context();
      Geant4Kernel&  krnl = kernel().worker(Geant4Kernel::thread_self(),true);
      updateContext(krnl.workerContext());
      m_sequence->constructField(&m_ctxt);
      m_sequence->constructSensitives(&m_ctxt);
      updateContext(ctx);
    }
 
    G4VPhysicalVolume* Geant4UserDetectorConstruction::Construct()    {
      G4AutoLock protection_lock(&action_mutex);
      updateContext(m_sequence->context());
      m_sequence->constructGeo(&m_ctxt);
      if ( nullptr == m_ctxt.world )    {
        m_sequence->except("+++ Executing G4 detector construction did not result in a valid world volume!");
      }
      m_sequence->context()->kernel().setWorld(m_ctxt.world);
      return m_ctxt.world;
    }
 
    void Geant4UserActionInitialization::Build()  const   {
      G4AutoLock protection_lock(&action_mutex);
      Geant4Kernel&  krnl = kernel().worker(Geant4Kernel::thread_self(),true);
      Geant4Context* ctx  = krnl.workerContext();
 
      if ( m_sequence )  {
        Geant4Context* old = m_sequence->context();
        m_sequence->info("+++ Executing Geant4UserActionInitialization::Build. "
                         "Context:%p Kernel:%p [%ld]", (void*)ctx, (void*)&krnl, krnl.id());
      
        m_sequence->updateContext(ctx);
        m_sequence->build();
        m_sequence->updateContext(old);
      }
      Geant4UserGeneratorAction* gen_action = new Geant4UserGeneratorAction(ctx,krnl.generatorAction(false));
      SetUserAction(gen_action);
 
      Geant4UserRunAction* run_action = new Geant4UserRunAction(ctx,krnl.runAction(false));
      SetUserAction(run_action);
 
      Geant4UserEventAction* evt_action = new Geant4UserEventAction(ctx,krnl.eventAction(false));
      run_action->eventAction = evt_action;
      evt_action->runAction = run_action;
      SetUserAction(evt_action);
 
      Geant4TrackingActionSequence* trk_action = krnl.trackingAction(false);
      if ( trk_action ) {
        Geant4UserTrackingAction* action = new Geant4UserTrackingAction(ctx, trk_action);
        SetUserAction(action);
      }
      Geant4SteppingActionSequence* stp_action = krnl.steppingAction(false);
      if ( stp_action ) {
        Geant4UserSteppingAction* action = new Geant4UserSteppingAction(ctx, stp_action);
        SetUserAction(action);
      }
      Geant4StackingActionSequence* stk_action = krnl.stackingAction(false);
      if ( stk_action ) {
        Geant4UserStackingAction* action = new Geant4UserStackingAction(ctx, stk_action);
        SetUserAction(action);
      }
      
    }
 
    void Geant4UserActionInitialization::BuildForMaster()  const  {
      if ( m_sequence )   {
        m_sequence->info("+++ Executing Geant4UserActionInitialization::BuildForMaster....");
        m_sequence->buildMaster();
      }
    }
    
 
    class Geant4Compatibility {
    public:
      Geant4Compatibility() = default;
      virtual ~Geant4Compatibility() = default;
      Geant4DetectorConstructionSequence* buildDefaultDetectorConstruction(Geant4Kernel& kernel);
    };
 
  }
}
 
#include <DD4hep/Detector.h>
#include <DD4hep/Plugins.h>
#include <DDG4/Geant4DetectorConstruction.h>
#include <DDG4/Geant4Kernel.h>
 
using namespace dd4hep::sim;
 
// Geant4 include files
#include <G4RunManager.hh>
#include <G4PhysListFactory.hh>
 
Geant4DetectorConstructionSequence* Geant4Compatibility::buildDefaultDetectorConstruction(Geant4Kernel& kernel)  {
  Geant4Action* cr;
  Geant4DetectorConstruction* det_cr;
  Geant4Context* ctx = kernel.workerContext();
  Geant4DetectorConstructionSequence* seq = kernel.detectorConstruction(true);
  printout(WARNING, "Geant4Exec", "+++ Building default Geant4DetectorConstruction for single threaded compatibility.");
 
  cr = PluginService::Create<Geant4Action*>("Geant4DetectorGeometryConstruction",ctx,std::string("ConstructGeometry"));
  det_cr = dynamic_cast<Geant4DetectorConstruction*>(cr);
  if ( det_cr ) 
    seq->adopt(det_cr);
  else
    throw std::runtime_error("Panic! Failed to build Geant4DetectorGeometryConstruction.");
  cr = PluginService::Create<Geant4Action*>("Geant4DetectorSensitivesConstruction",ctx,std::string("ConstructSensitives"));
  det_cr = dynamic_cast<Geant4DetectorConstruction*>(cr);
  if ( det_cr )
    seq->adopt(det_cr);
  else
    throw std::runtime_error("Panic! Failed to build Geant4DetectorSensitivesConstruction.");
  return seq;
}
 
int Geant4Exec::configure(Geant4Kernel& kernel) {
  Detector& description = kernel.detectorDescription();
  Geant4Context* ctx = kernel.workerContext();
  Geant4Random* rndm = Geant4Random::instance(false);
  
  if ( !rndm )  {
    rndm = new Geant4Random(ctx, "Geant4Random");
    rndm->initialize();
  }
  Geant4Random::setMainInstance(rndm);
  kernel.executePhase("configure",0);
 
  G4RunManager& runManager = kernel.runManager();
 
  if (description.sensitiveDetectors().size() <= 1) {
    printout(WARNING, "Geant4Exec", "+++ Only %d subdetectors present. "
             "You sure you loaded the geometry properly?",
             int(description.sensitiveDetectors().size()));
  }
 
  Geant4DetectorConstructionSequence* user_det = kernel.detectorConstruction(false);
  if ( nullptr == user_det && kernel.isMultiThreaded() )   {
    throw std::runtime_error("Panic! No valid detector construction sequencer present. [Mandatory MT]");
  }
  if ( nullptr == user_det && !kernel.isMultiThreaded() )   {
    user_det = Geant4Compatibility().buildDefaultDetectorConstruction(kernel);
  }
  Geant4UserDetectorConstruction* det_seq = new Geant4UserDetectorConstruction(ctx,user_det);
  runManager.SetUserInitialization(det_seq);
 
  Geant4PhysicsListActionSequence* phys_seq = kernel.physicsList(false);
  if ( nullptr == phys_seq )   {
    std::string phys_model = "QGSP_BERT";
    phys_seq = kernel.physicsList(true);
    phys_seq->property("extends").set(phys_model);
  }
  G4VUserPhysicsList* physics = phys_seq->extensionList();
  if (nullptr == physics) {
    throw std::runtime_error("Panic! No valid user physics list present!");
  }
#if 0
  printout(INFO, "Geant4Exec", "+++ PhysicsList RangeCut: %f", phys_seq->m_rangecut );
  physics->SetDefaultCutValue(phys_seq->m_rangecut);
  physics->SetCuts();
  if( DEBUG == printLevel() ) physics->DumpCutValuesTable();
#endif
  phys_seq->enable(physics);
  runManager.SetUserInitialization(physics);
 
  Geant4UserInitializationSequence* user_init = kernel.userInitialization(false);
  if ( nullptr == user_init && kernel.isMultiThreaded() )   {
    throw std::runtime_error("Panic! No valid user initialization sequencer present. [Mandatory MT]");
  }
  else if ( nullptr == user_init && !kernel.isMultiThreaded() )  {
    user_init = kernel.userInitialization(true);
  }
  Geant4UserActionInitialization* init = new Geant4UserActionInitialization(ctx,user_init);
  runManager.SetUserInitialization(init);
  return 1;
}
 
int Geant4Exec::initialize(Geant4Kernel& kernel) {
  G4RunManager& runManager = kernel.runManager();
  kernel.applyInterruptHandlers();
  kernel.executePhase("initialize",0);
  runManager.Initialize();
  return 1;
}
 
int Geant4Exec::run(Geant4Kernel& kernel) {
  Property& p = kernel.property("UI");
  std::string value = p.value<std::string>();
 
  kernel.executePhase("start",0);
  if ( !value.empty() )  {
    Geant4Action* ui = kernel.globalAction(value);
    if ( ui )  {
      Geant4Call* c = dynamic_cast<Geant4Call*>(ui);
      if ( c )  {
        (*c)(nullptr);
        kernel.executePhase("stop",0);
        return 1;
      }
      ui->except("++ Geant4Exec: Failed to start UI interface.");
    }
    throw std::runtime_error(format("Geant4Exec","++ Failed to locate UI interface %s.",value.c_str()));
  }
  long nevt = kernel.property("NumEvents").value<long>();
  kernel.applyInterruptHandlers();
  kernel.runManager().BeamOn(nevt);
  kernel.executePhase("stop",0);
  return 1;
}
 
int Geant4Exec::terminate(Geant4Kernel& kernel) {
  kernel.executePhase("terminate",0);
  return 1;
}