G4RunManagerFactory Class Reference

#include <G4RunManagerFactory.hh>

Static Public Member Functions
static G4RunManager *	CreateRunManager (G4RunManagerType _type=G4RunManagerType::Default, G4VUserTaskQueue *_queue=nullptr, G4bool fail_if_unavail=true, G4int nthreads=0)
static G4RunManager *	CreateRunManager (G4RunManagerType _type, G4bool fail_if_unavail, G4int nthreads=0, G4VUserTaskQueue *_queue=nullptr)
static G4RunManager *	CreateRunManager (G4RunManagerType _type, G4int nthreads, G4bool fail_if_unavail=true, G4VUserTaskQueue *_queue=nullptr)
template<typename... Args>
static G4RunManager *	CreateRunManager (std::string type, Args &&... args)
static std::string	GetDefault ()
static std::string	GetName (G4RunManagerType)
static G4RunManagerType	GetType (const std::string &)
static std::set< std::string >	GetOptions ()
static G4RunManager *	GetMasterRunManager ()
static G4MTRunManager *	GetMTMasterRunManager ()
static G4RunManagerKernel *	GetMasterRunManagerKernel ()

Detailed Description

Definition at line 67 of file G4RunManagerFactory.hh.

Member Function Documentation

CreateRunManager() [1/4]

static G4RunManager * G4RunManagerFactory::CreateRunManager ( G4RunManagerType _type, G4bool fail_if_unavail, G4int nthreads = 0, G4VUserTaskQueue * _queue = nullptr )

inlinestatic

Definition at line 75 of file G4RunManagerFactory.hh.

    {
      return CreateRunManager(_type, _queue, fail_if_unavail, nthreads);
    }

CreateRunManager() [2/4]

static G4RunManager * G4RunManagerFactory::CreateRunManager ( G4RunManagerType _type, G4int nthreads, G4bool fail_if_unavail = true, G4VUserTaskQueue * _queue = nullptr )

inlinestatic

Definition at line 81 of file G4RunManagerFactory.hh.

    {
      return CreateRunManager(_type, _queue, fail_if_unavail, nthreads);
    }

CreateRunManager() [3/4]

G4RunManager * G4RunManagerFactory::CreateRunManager ( G4RunManagerType _type = G4RunManagerType::Default, G4VUserTaskQueue * _queue = nullptr, G4bool fail_if_unavail = true, G4int nthreads = 0 )

static

Definition at line 65 of file G4RunManagerFactory.cc.

{
  // If the supplied type is not ...Only, then allow override from environment
  std::string rm_type = GetName(_type);
  if (_type == G4RunManagerType::SerialOnly || _type == G4RunManagerType::MTOnly
      || _type == G4RunManagerType::TaskingOnly || _type == G4RunManagerType::TBBOnly
      || _type == G4RunManagerType::SubEvtOnly)
  {
    // MUST fail if unavail in this case
    fail_if_unavail = true;
  }
  else {
    // - G4RUN_MANAGER_TYPE can be set to override the "default"
    //   - If the requested type isn't available, then it will fall back to the
    //   system default
    // - G4FORCE_RUN_MANAGER_TYPE can be set to force a specific type
    //   - A G4Exception is raised if the requested type is not available
    rm_type = G4GetEnv<std::string>("G4RUN_MANAGER_TYPE", GetName(_type),
                                    "Overriding G4RunManager type...");
    auto force_rm =
      G4GetEnv<std::string>("G4FORCE_RUN_MANAGER_TYPE", "", "Forcing G4RunManager type...");
 
    if (force_rm.length() > 0) {
      rm_type = std::move(force_rm);
      fail_if_unavail = true;
    }
    else if (rm_type.empty()) {
      rm_type = GetDefault();
    }
  }
 
  // At this point will have a string for the RM type we can check for existence
  // NB: Comparison at present is case sensitive (needs a comparator in
  // GetOptions)
  auto opts = GetOptions();
  if (opts.find(rm_type) == opts.end()) {
    if (fail_if_unavail) {
      fail("Run manager type is not available", rm_type, opts, 1);
    }
    else {
      rm_type = GetDefault();
    }
  }
 
  // Construct requested RunManager given type
  _type = GetType(rm_type);
  G4RunManager* rm = nullptr;
 
  switch (_type) {
    case G4RunManagerType::Serial:
      rm = new G4RunManager();
      break;
    case G4RunManagerType::MT:
#if defined(G4MULTITHREADED)
      rm = new G4MTRunManager();
#endif
      break;
    case G4RunManagerType::Tasking:
#if defined(G4MULTITHREADED)
      rm = new G4TaskRunManager(_queue, false);
#endif
      break;
    case G4RunManagerType::TBB:
#if defined(G4MULTITHREADED) && defined(GEANT4_USE_TBB)
      rm = new G4TaskRunManager(_queue, true);
#endif
      break;
    case G4RunManagerType::SubEvt:
#if defined(G4MULTITHREADED)
#if defined(GEANT4_USE_TBB)
      rm = new G4SubEvtRunManager(_queue, true);
#else
      rm = new G4SubEvtRunManager(_queue, false);
#endif
#endif
      break;
    // "Only" types are not handled since they are converted above to main type
    case G4RunManagerType::SerialOnly:
      break;
    case G4RunManagerType::MTOnly:
      break;
    case G4RunManagerType::TaskingOnly:
      break;
    case G4RunManagerType::TBBOnly:
      break;
    case G4RunManagerType::SubEvtOnly:
      break;
    case G4RunManagerType::Default:
      break;
  }
 
  if (rm == nullptr) fail("Failure creating run manager", GetName(_type), GetOptions(), 2);
 
  auto mtrm = dynamic_cast<G4MTRunManager*>(rm);
  if (nthreads > 0 && (mtrm != nullptr)) mtrm->SetNumberOfThreads(nthreads);
 
  master_run_manager = rm;
  mt_master_run_manager = mtrm;
  master_run_manager_kernel = rm->kernel;
 
  G4ConsumeParameters(_queue);
  return rm;
}

Referenced by CreateRunManager(), CreateRunManager(), and CreateRunManager().

CreateRunManager() [4/4]

template<typename... Args>

static G4RunManager * G4RunManagerFactory::CreateRunManager ( std::string type, Args &&... args )

inlinestatic

Definition at line 90 of file G4RunManagerFactory.hh.

    {
      return CreateRunManager(GetType(type), std::forward<Args>(args)...);
    }

GetDefault()

std::string G4RunManagerFactory::GetDefault ( )

static

Definition at line 173 of file G4RunManagerFactory.cc.

{
#if defined(G4MULTITHREADED)
  return "Tasking";
#else
  return "Serial";
#endif
}

Referenced by CreateRunManager().

GetMasterRunManager()

G4RunManager * G4RunManagerFactory::GetMasterRunManager ( )

static

Definition at line 249 of file G4RunManagerFactory.cc.

{
#if !defined(G4MULTITHREADED)
  // if serial build just return G4RunManager
  return G4RunManager::GetRunManager();
#else
  // if the application used G4RunManagerFactory to create the run-manager
  if (master_run_manager != nullptr) return master_run_manager;
 
  // if the application did not use G4RunManagerFactory and is MT
  if (G4Threading::IsMultithreadedApplication()) {
    auto mt_rm = GetMTMasterRunManager();
    if (mt_rm != nullptr) return mt_rm;
  }
 
  // if the application did not use G4RunManagerFactory and is serial
  return G4RunManager::GetRunManager();
#endif
}

Referenced by G4TrajectoriesModel::DescribeYourselfTo(), G4VisManager::Draw(), G4VSceneHandler::ProcessScene(), G4OpenGLSceneHandler::ScaledFlush(), G4VisCommandReviewKeptEvents::SetNewValue(), and G4VisCommandSceneEndOfEventAction::SetNewValue().

GetMasterRunManagerKernel()

G4RunManagerKernel * G4RunManagerFactory::GetMasterRunManagerKernel ( )

static

Definition at line 290 of file G4RunManagerFactory.cc.

{
#if !defined(G4MULTITHREADED)
  // if serial build just return G4RunManager
  return G4RunManager::GetRunManager()->kernel;
#else
  // if the application used G4RunManagerFactory to create the run-manager
  if (master_run_manager_kernel != nullptr) return master_run_manager_kernel;
 
  // if the application did not use G4RunManagerFactory and is MT
  if (G4Threading::IsMultithreadedApplication()) {
    auto mt_rm = GetMTMasterRunManager();
    if (mt_rm != nullptr) return mt_rm->kernel;
  }
 
  // if the application did not use G4RunManagerFactory and is serial
  return G4RunManager::GetRunManager()->kernel;
#endif
}

Referenced by G4VisManager::G4VisSubThread().

GetMTMasterRunManager()

G4MTRunManager * G4RunManagerFactory::GetMTMasterRunManager ( )

static

Definition at line 271 of file G4RunManagerFactory.cc.

{
#if defined(G4MULTITHREADED)
  // if the application used G4RunManagerFactory to create the run-manager
  if (mt_master_run_manager != nullptr) return mt_master_run_manager;
 
  // if the application did not use G4RunManagerFactory
  if (G4Threading::IsMultithreadedApplication()) {
    auto task_rm = G4TaskRunManager::GetMasterRunManager();
    if (task_rm != nullptr) return task_rm;
    return G4MTRunManager::GetMasterRunManager();
  }
#endif
 
  return nullptr;
}

Referenced by G4TheMTRayTracer::CreateBitMap(), GetMasterRunManager(), GetMasterRunManagerKernel(), G4TheMTRayTracer::RestoreUserActions(), and G4TheMTRayTracer::StoreUserActions().

GetName()

std::string G4RunManagerFactory::GetName ( G4RunManagerType _type )

static

Definition at line 218 of file G4RunManagerFactory.cc.

{
  switch (_type) {
    case G4RunManagerType::Serial:
      return "Serial";
    case G4RunManagerType::SerialOnly:
      return "Serial";
    case G4RunManagerType::MT:
      return "MT";
    case G4RunManagerType::MTOnly:
      return "MT";
    case G4RunManagerType::Tasking:
      return "Tasking";
    case G4RunManagerType::TaskingOnly:
      return "Tasking";
    case G4RunManagerType::TBB:
      return "TBB";
    case G4RunManagerType::TBBOnly:
      return "TBB";
    case G4RunManagerType::SubEvt:
      return "SubEvt";
    case G4RunManagerType::SubEvtOnly:
      return "SubEvt";
    default:
      break;
  };
  return "";
}

Referenced by CreateRunManager().

GetOptions()

std::set< std::string > G4RunManagerFactory::GetOptions ( )

static

Definition at line 184 of file G4RunManagerFactory.cc.

{
  static auto _instance = []() {
    std::set<std::string> options = {"Serial"};
#if defined(G4MULTITHREADED)
    options.insert({"MT", "Tasking"});
#  if defined(GEANT4_USE_TBB)
    options.insert("TBB");
#  endif
    options.insert("SubEvt");
#endif
    return options;
  }();
  return _instance;
}

Referenced by CreateRunManager().

GetType()

G4RunManagerType G4RunManagerFactory::GetType ( const std::string & key )

static

Definition at line 202 of file G4RunManagerFactory.cc.

{
  // IGNORES CASE!
  static const auto opts = std::regex::icase;
 
  if (std::regex_match(key, std::regex("^(Serial).*", opts))) return G4RunManagerType::Serial;
  if (std::regex_match(key, std::regex("^(MT).*", opts))) return G4RunManagerType::MT;
  if (std::regex_match(key, std::regex("^(Task).*", opts))) return G4RunManagerType::Tasking;
  if (std::regex_match(key, std::regex("^(TBB).*", opts))) return G4RunManagerType::TBB;
  if (std::regex_match(key, std::regex("^(SubEvt).*", opts))) return G4RunManagerType::SubEvt;
 
  return G4RunManagerType::Default;
}

Referenced by CreateRunManager(), and CreateRunManager().

---

The documentation for this class was generated from the following files:

• G4RunManagerFactory.hh
• G4RunManagerFactory.cc