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 65 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 74 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 82 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 63 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)
  {
    // 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         = 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;
    // "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::Default:
      break;
  }
 
  if(!rm)
    fail("Failure creating run manager", GetName(_type), GetOptions(), 2);
 
  auto mtrm = dynamic_cast<G4MTRunManager*>(rm);
  if(nthreads > 0 && mtrm)
    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() [4/4]

template<typename... Args>

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

inlinestatic

Definition at line 91 of file G4RunManagerFactory.hh.

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

GetDefault()

std::string G4RunManagerFactory::GetDefault ( )

static

Definition at line 171 of file G4RunManagerFactory.cc.

{
#if defined(G4MULTITHREADED)
  // For version 10.7, default is set to MT
  //  return "MT";
  return "Tasking";
#else
  return "Serial";
#endif
}

Referenced by CreateRunManager().

GetMasterRunManager()

G4RunManager * G4RunManagerFactory::GetMasterRunManager ( )

static

Definition at line 248 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)
    return master_run_manager;
 
  // if the application did not use G4RunManagerFactory and is MT
  if(G4Threading::IsMultithreadedApplication())
  {
    auto mt_rm = GetMTMasterRunManager();
    if(mt_rm)
      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 295 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)
    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)
      return mt_rm->kernel;
  }
 
  // if the application did not use G4RunManagerFactory and is serial
  return G4RunManager::GetRunManager()->kernel;
#endif
}

GetMTMasterRunManager()

G4MTRunManager * G4RunManagerFactory::GetMTMasterRunManager ( )

static

Definition at line 273 of file G4RunManagerFactory.cc.

{
#if defined(G4MULTITHREADED)
  // if the application used G4RunManagerFactory to create the run-manager
  if(mt_master_run_manager)
    return mt_master_run_manager;
 
  // if the application did not use G4RunManagerFactory
  if(G4Threading::IsMultithreadedApplication())
  {
    auto task_rm = G4TaskRunManager::GetMasterRunManager();
    if(task_rm)
      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 220 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";
    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
#endif
    return options;
  }();
  return _instance;
}

Referenced by CreateRunManager().

GetType()

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

static

Definition at line 201 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;
  else if(std::regex_match(key, std::regex("^(MT).*", opts)))
    return G4RunManagerType::MT;
  else if(std::regex_match(key, std::regex("^(Task).*", opts)))
    return G4RunManagerType::Tasking;
  else if(std::regex_match(key, std::regex("^(TBB).*", opts)))
    return G4RunManagerType::TBB;
 
  return G4RunManagerType::Default;
}

Referenced by CreateRunManager().

---

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

• G4RunManagerFactory.hh
• G4RunManagerFactory.cc