Geant4UIManager.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
//
//==========================================================================
 
#include <DDG4/Geant4UIManager.h>
#include <DDG4/Geant4Kernel.h>
#include <DDG4/Geant4UIMessenger.h>
#include <DD4hep/Primitives.h>
 
#include <G4Version.hh>
#include <G4VisExecutive.hh>
#include <G4UImanager.hh>
#include <G4UIsession.hh>
#include <G4VisExecutive.hh>
#include <G4UIExecutive.hh>
#include <G4RunManager.hh>
 
#include <cstdlib>
#include <functional>
 
using namespace dd4hep::sim;
 
namespace   {
  std::string make_cmd(const std::string& cmd)  {
    return std::string( "/control/execute "+cmd);
  }
}
 
Geant4UIManager::Geant4UIManager(Geant4Context* ctxt, const std::string& nam)
  : Geant4Action(ctxt,nam), m_vis(0), m_ui(0)
{
  declareProperty("SetupUI",            m_uiSetup="");
  declareProperty("SetupVIS",           m_visSetup="");
  declareProperty("SessionType",        m_sessionType="tcsh");
  declareProperty("Macros",             m_macros);
  declareProperty("ConfigureCommands",  m_configureCommands);
  declareProperty("InitializeCommands", m_initializeCommands);
  declareProperty("TerminateCommands",  m_terminateCommands);
  declareProperty("Commands",           m_preRunCommands);
  declareProperty("PreRunCommands",     m_preRunCommands);
  declareProperty("PostRunCommands",    m_postRunCommands);
  declareProperty("HaveVIS",            m_haveVis=false);
  declareProperty("HaveUI",             m_haveUI=true);
  declareProperty("Prompt",             m_prompt);
  context()->kernel().register_configure(std::bind(&Geant4UIManager::configure,this));
  context()->kernel().register_initialize(std::bind(&Geant4UIManager::initialize,this));
  context()->kernel().register_terminate(std::bind(&Geant4UIManager::terminate,this));
  enableUI();
}
 
Geant4UIManager::~Geant4UIManager()   {
}
 
void Geant4UIManager::configure()   {
  G4UImanager* mgr = G4UImanager::GetUIpointer();
  if ( m_haveUI ) {
    m_ui = startUI();
  }
  for(const auto& c : m_configureCommands)  {
    info("++ Executing configure command: %s",c.c_str());
    G4int ret = mgr->ApplyCommand(c.c_str());
    if ( ret != 0 )  {
      except("Failed to execute command: %s",c.c_str());
    }
  }
}
 
void Geant4UIManager::initialize()   {
  G4UImanager* mgr = G4UImanager::GetUIpointer();
  for(const auto& c : m_initializeCommands)  {
    info("++ Executing initialization command: %s",c.c_str());
    G4int ret = mgr->ApplyCommand(c.c_str());
    if ( ret != 0 )  {
      except("Failed to execute command: %s",c.c_str());
    }
  }
}
 
void Geant4UIManager::terminate() {
  G4UImanager* mgr = G4UImanager::GetUIpointer();
  for(const auto& c : m_terminateCommands)  {
    info("++ Executing finalization command: %s",c.c_str());
    G4int ret = mgr->ApplyCommand(c.c_str());
    if ( ret != 0 )  {
      except("Failed to execute command: %s",c.c_str());
    }
  }
}
 
void Geant4UIManager::applyCommand(const std::string& command)   {
  G4UImanager* mgr = G4UImanager::GetUIpointer();
  if ( mgr )    {
    info("++ Executing G4 command: %s",command.c_str());
    G4int ret = mgr->ApplyCommand(command.c_str());
    if ( ret == 0 )  {
      return;
    }
    except("Failed to execute command: %s",command.c_str());
  }
  except("No UI reference present. Too early to interact with Geant4!");
}
 
void Geant4UIManager::installCommandMessenger()   {
  m_control->addCall("exit", "Force exiting this process",
                     Callback(this).make(&Geant4UIManager::forceExit),0);
  m_control->addCall("terminate", "Regular exit this process",
                     Callback(this).make(&Geant4UIManager::regularExit),0);
}
 
void Geant4UIManager::forceExit()   {
  std::_Exit(0);
}
 
void Geant4UIManager::regularExit()   {
  info("++ End of processing requested.");
  context()->kernel().terminate();
  forceExit();
}
 
G4VisManager* Geant4UIManager::startVis()  {
  info("+++ Starting G4VisExecutive ....");
  G4VisManager* vis = new G4VisExecutive();
  vis->Initialize();
  return vis;
}
 
G4UIExecutive* Geant4UIManager::startUI()   {
  G4UIExecutive* ui = 0;
  const char* args[] = {"DDG4","",""};
  info("+++ Starting G4UIExecutive '%s' of type %s....", args[0], m_sessionType.c_str());
#if (G4VERSION_NUMBER >= 960)
  ui = new G4UIExecutive(1,(char**)args,m_sessionType.c_str());
#else
  ui = new G4UIExecutive(1,(char**)args );
#endif
  if ( !m_prompt.empty() )  {
    ui->SetPrompt(m_prompt);
  }
  return ui;
}
 
void Geant4UIManager::operator()(void* )   {
  start();
  stop();
}
 
void Geant4UIManager::start() {
  G4UImanager* mgr = G4UImanager::GetUIpointer();
  bool executed_statements = false;
 
  if ( m_haveVis || !m_visSetup.empty() ) {
    m_vis = startVis();
    m_haveVis = true;   
    m_haveUI = true;    
  }
  if ( !m_visSetup.empty() ) {
    info("++ Executing visualization setup: %s",m_visSetup.c_str());
    mgr->ApplyCommand(make_cmd(m_visSetup).c_str());
  }
  if ( !m_uiSetup.empty() )   {
    info("++ Executing UI setup: %s",m_uiSetup.c_str());
    mgr->ApplyCommand(make_cmd(m_uiSetup).c_str());
    executed_statements = true;
  }
  for(const auto& m : m_macros)  {
    info("++ Executing Macro file: %s",m.c_str());
    mgr->ApplyCommand(make_cmd(m.c_str()));
    executed_statements = true;
  }
  for(const auto& c : m_preRunCommands)  {
    info("++ Executing pre-run statement: %s",c.c_str());
    G4int ret = mgr->ApplyCommand(c.c_str());
    if ( ret != 0 )  {
      except("Failed to execute command: %s",c.c_str());
    }
    executed_statements = true;
  }
  if ( m_haveUI && m_ui )   {
    m_ui->SessionStart();
    for(const auto& c : m_postRunCommands)  {
      info("++ Executing post-run statement: %s",c.c_str());
      G4int ret = mgr->ApplyCommand(c.c_str());
      if ( ret != 0 )  {
        except("Failed to execute command: %s",c.c_str());
      }
      executed_statements = true;
    }
    return;
  }
  else if ( m_haveUI )   {
    warning("++ No UI manager found. Exit.");
    return;
  }
  else if ( executed_statements )  {
    for(const auto& c : m_postRunCommands)  {
      info("++ Executing post-run statement: %s",c.c_str());
      G4int ret = mgr->ApplyCommand(c.c_str());
      if ( ret != 0 )  {
        except("Failed to execute command: %s",c.c_str());
      }
    }
    return;
  }
 
  long numEvent = context()->kernel().property("NumEvents").value<long>();
  if(numEvent < 0) numEvent = std::numeric_limits<int>::max();
  info("++ Start run with %d events.",numEvent);
  try {
    context()->kernel().runManager().BeamOn(numEvent);
  }
  catch (DD4hep_End_Of_File& e) {
    info("++ End of file reached, ending run...");
    context()->kernel().runManager().RunTermination();
  }
}
 
void Geant4UIManager::stop() {
  detail::deletePtr(m_vis);
  detail::deletePtr(m_ui);
}