Geant4Action.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/InstanceCount.h>
#include <DDG4/Geant4Context.h>
#include <DDG4/Geant4Action.h>
#include <DDG4/Geant4Kernel.h>
#include <DDG4/Geant4UIMessenger.h>
 
// Geant4 include files
#include <G4UIdirectory.hh>
 
// C/C++ include files
#include <algorithm>
 
using namespace dd4hep::sim;
 
TypeName TypeName::split(const std::string& type_name, const std::string& delim) {
  size_t idx = type_name.find(delim);
  std::string typ = type_name, nam = type_name;
  if (idx != std::string::npos) {
    typ = type_name.substr(0, idx);
    nam = type_name.substr(idx + 1);
  }
  return TypeName(typ, nam);
}
 
TypeName TypeName::split(const std::string& type_name) {
  return split(type_name,"/");
}
#if 0
void Geant4Action::ContextUpdate::operator()(Geant4Action* action) const  {
  action->m_context = context;
  if ( 0 == action->m_context )   {
 
    cout << "ERROR" << endl;
 
  }
}
#endif
Geant4Action::Geant4Action(Geant4Context* ctxt, const std::string& nam)
  : m_context(ctxt), m_outputLevel(INFO), m_name(nam)
{
  InstanceCount::increment(this);
  m_outputLevel = ctxt ? ctxt->kernel().getOutputLevel(nam) : (printLevel()-1);
  declareProperty("Name", m_name);
  declareProperty("name", m_name);
  declareProperty("OutputLevel", m_outputLevel);
  declareProperty("Control", m_needsControl);
}
 
Geant4Action::~Geant4Action() {
  InstanceCount::decrement(this);
}
 
long Geant4Action::addRef() {
  return ++m_refCount;
}
 
long Geant4Action::release() {
  long count = --m_refCount;
  if (m_refCount <= 0) {
    printM1("Geant4Action: Deleting object %s of type %s Pointer:%p",
            m_name.c_str(),typeName(typeid(*this)).c_str(),(void*)this);
    delete this;
  }
  return count;
}
 
dd4hep::PrintLevel Geant4Action::setOutputLevel(PrintLevel new_level)  {
  int old = m_outputLevel;
  m_outputLevel = new_level;
  return (PrintLevel)old;
}
 
bool Geant4Action::hasProperty(const std::string& nam) const    {
  return m_properties.exists(nam);
}
 
dd4hep::Property& Geant4Action::property(const std::string& nam)   {
  return properties()[nam];
}
 
void Geant4Action::installMessengers() {
  //m_needsControl = true;
  if (m_needsControl && !m_control) {
    std::string path = context()->kernel().directoryName();
    path += name() + "/";
    m_control = new Geant4UIMessenger(name(), path);
    installPropertyMessenger();
    installCommandMessenger();
  }
}
 
void Geant4Action::installPropertyMessenger() {
  m_control->exportProperties(m_properties);
}
 
void Geant4Action::installCommandMessenger()   {
}
 
Geant4UIMessenger* Geant4Action::control() const   {
  if ( m_control )   {
    return m_control;
  }
  except("No control was installed for this action item.");
  return 0;
}
 
void Geant4Action::enableUI()   {
  m_needsControl = true;
  installMessengers();
}
 
void Geant4Action::configureFiber(Geant4Context* /* thread_context */)   {
}
 
void Geant4Action::print(const char* fmt, ...) const   {
  int level = std::max(int(outputLevel()),(int)VERBOSE);
  if ( level >= printLevel() )  {
    va_list args;
    va_start(args, fmt);
    dd4hep::printout((PrintLevel)level, m_name.c_str(), fmt, args);
    va_end(args);
  }
}
 
void Geant4Action::printM1(const char* fmt, ...) const   {
  int level = std::max(outputLevel()-1,(int)VERBOSE);
  if ( level >= printLevel() )  {
    va_list args;
    va_start(args, fmt);
    dd4hep::printout((PrintLevel)level, m_name.c_str(), fmt, args);
    va_end(args);
  }
}
 
void Geant4Action::printM2(const char* fmt, ...) const   {
  int level = std::max(outputLevel()-2,(int)VERBOSE);
  if ( level >= printLevel() )  {
    va_list args;
    va_start(args, fmt);
    dd4hep::printout((PrintLevel)level, m_name.c_str(), fmt, args);
    va_end(args);
  }
}
 
void Geant4Action::printP1(const char* fmt, ...) const   {
  int level = std::min(outputLevel()+1,(int)FATAL);
  if ( level >= printLevel() )  {
    va_list args;
    va_start(args, fmt);
    dd4hep::printout((PrintLevel)level, m_name.c_str(), fmt, args);
    va_end(args);
  }
}
 
void Geant4Action::printP2(const char* fmt, ...) const   {
  int level = std::min(outputLevel()+2,(int)FATAL);
  if ( level >= printLevel() )  {
    va_list args;
    va_start(args, fmt);
    dd4hep::printout((PrintLevel)level, m_name.c_str(), fmt, args);
    va_end(args);
  }
}
 
void Geant4Action::always(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::ALWAYS, m_name, fmt, args);
  va_end(args);
}
 
void Geant4Action::debug(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::DEBUG, m_name, fmt, args);
  va_end(args);
}
 
void Geant4Action::info(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::INFO, m_name, fmt, args);
  va_end(args);
}
 
void Geant4Action::warning(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::WARNING, m_name, fmt, args);
  va_end(args);
}
 
void Geant4Action::error(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::ERROR, m_name, fmt, args);
  va_end(args);
}
 
bool Geant4Action::return_error(bool return_value, const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::ERROR, m_name, fmt, args);
  va_end(args);
  return return_value;
}
 
void Geant4Action::fatal(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  dd4hep::printout(dd4hep::FATAL, m_name, fmt, args);
  va_end(args);
}
 
void Geant4Action::except(const char* fmt, ...) const {
  va_list args;
  va_start(args, fmt);
  std::string err = dd4hep::format(m_name, fmt, args);
  dd4hep::printout(dd4hep::FATAL, m_name, err.c_str());
  va_end(args);
  throw std::runtime_error(err);
}
 
void Geant4Action::abortRun(const std::string& exception, const char* fmt, ...) const {
  std::string desc, typ = typeName(typeid(*this));
  std::string issuer = name()+" ["+typ+"]";
  va_list args;
  va_start(args, fmt);
  desc = dd4hep::format("*** Geant4Action:", fmt, args);
  va_end(args);
  G4Exception(issuer.c_str(),exception.c_str(),RunMustBeAborted,desc.c_str());
  //throw std::runtime_error(issuer+"> "+desc);
}
 
Geant4RunActionSequence& Geant4Action::runAction() const {
  return m_context->kernel().runAction();
}
 
Geant4EventActionSequence& Geant4Action::eventAction() const {
  return m_context->kernel().eventAction();
}
 
Geant4SteppingActionSequence& Geant4Action::steppingAction() const {
  return m_context->kernel().steppingAction();
}
 
Geant4TrackingActionSequence& Geant4Action::trackingAction() const {
  return m_context->kernel().trackingAction();
}
 
Geant4StackingActionSequence& Geant4Action::stackingAction() const {
  return m_context->kernel().stackingAction();
}
 
Geant4GeneratorActionSequence& Geant4Action::generatorAction() const {
  return m_context->kernel().generatorAction();
}