#include <RunManagerMT.h>

Public Member Functions
const SensitiveDetectorCatalog &	catalog () const

void	Connect (RunAction *)

const std::vector< std::string > &	G4Commands () const

void	initG4 (const DDCompactView , const cms::DDCompactView , const HepPDT::ParticleDataTable *)

void	initializeUserActions ()

PhysicsList *	physicsListForWorker () const

	RunManagerMT (edm::ParameterSet const &)

void	stopG4 ()

const DDDWorld &	world () const

	~RunManagerMT ()

Private Member Functions
void	checkVoxels ()

void	setupVoxels ()

void	terminateRun ()

Private Attributes
SensitiveDetectorCatalog	m_catalog

bool	m_check

G4Run *	m_currentRun

std::vector< std::string >	m_G4Commands

edm::ParameterSet	m_g4overlap

G4MTRunManagerKernel *	m_kernel

bool	m_managerInitialized

edm::ParameterSet	m_p

std::unique_ptr< PhysicsList >	m_physicsList

const std::string	m_PhysicsTablesDir

edm::ParameterSet	m_pPhysics

edm::ParameterSet	m_pRunAction

SimActivityRegistry	m_registry

bool	m_RestorePhysicsTables

std::unique_ptr< SimRunInterface >	m_runInterface

bool	m_runTerminated

G4StateManager *	m_stateManager

bool	m_StorePhysicsTables

CustomUIsession *	m_UIsession

RunAction *	m_userRunAction

std::unique_ptr< DDDWorld >	m_world

Friends
class	RunManagerMTWorker

Detailed Description

Definition at line 51 of file RunManagerMT.h.

Constructor & Destructor Documentation

◆ RunManagerMT()

RunManagerMT::RunManagerMT ( edm::ParameterSet const & p )

explicit

Definition at line 68 of file RunManagerMT.cc.

References g4SimHits_cfi::CustomUIsession, m_check, m_currentRun, m_kernel, m_physicsList, m_runInterface, m_stateManager, m_UIsession, m_userRunAction, m_world, and AlCaHLTBitMon_ParallelJobs::p.

     : m_managerInitialized(false),
       m_runTerminated(false),
       m_PhysicsTablesDir(p.getUntrackedParameter<std::string>("PhysicsTablesDirectory", "")),
       m_StorePhysicsTables(p.getUntrackedParameter<bool>("StorePhysicsTables", false)),
       m_RestorePhysicsTables(p.getUntrackedParameter<bool>("RestorePhysicsTables", false)),
       m_pPhysics(p.getParameter<edm::ParameterSet>("Physics")),
       m_pRunAction(p.getParameter<edm::ParameterSet>("RunAction")),
       m_g4overlap(p.getUntrackedParameter<edm::ParameterSet>("G4CheckOverlap")),
       m_G4Commands(p.getParameter<std::vector<std::string> >("G4Commands")),
       m_p(p) {
   m_currentRun = nullptr;
   m_UIsession = new CustomUIsession();
   m_physicsList.reset(nullptr);
   m_world.reset(nullptr);
 
   m_runInterface.reset(nullptr);
   m_userRunAction = nullptr;
   m_currentRun = nullptr;
 
   m_kernel = new G4MTRunManagerKernel();
   m_stateManager = G4StateManager::GetStateManager();
   double th = p.getParameter<double>("ThresholdForGeometryExceptions") * CLHEP::GeV;
   bool tr = p.getParameter<bool>("TraceExceptions");
   m_stateManager->SetExceptionHandler(new ExceptionHandler(th, tr));
   m_check = p.getUntrackedParameter<bool>("CheckGeometry", false);
 }

◆ ~RunManagerMT()

RunManagerMT::~RunManagerMT ( )

Definition at line 96 of file RunManagerMT.cc.

References m_UIsession.

96 { delete m_UIsession; }

RunManagerMT::m_UIsession

CustomUIsession * m_UIsession

Definition: RunManagerMT.h:89

Member Function Documentation

◆ catalog()

const SensitiveDetectorCatalog& RunManagerMT::catalog ( ) const

inline

Definition at line 72 of file RunManagerMT.h.

References m_catalog.

Referenced by RunManagerMTWorker::initializeG4().

72 { return m_catalog; }

RunManagerMT::m_catalog

SensitiveDetectorCatalog m_catalog

Definition: RunManagerMT.h:111

◆ checkVoxels()

void RunManagerMT::checkVoxels ( )

private

Definition at line 311 of file RunManagerMT.cc.

References mps_fire::i, rname, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by initG4().

                                {
   const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
   int numLV = lvs->size();
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT: nLV=" << numLV;
   int nvox = 0;
   int nslice = 0;
   for (int i = 0; i < numLV; ++i) {
     auto lv = (*lvs)[i];
     auto nd = lv->GetNoDaughters();
     auto vox = lv->GetVoxelHeader();
     auto sma = lv->GetSmartless();
     auto reg = lv->GetRegion();
     size_t nsl = (nullptr == vox) ? 0 : vox->GetNoSlices();
     if (0 < nsl) {
       nslice += nsl;
       std::string rname = (nullptr != reg) ? reg->GetName() : "";
       edm::LogVerbatim("Voxels") << " " << i << ". Nd=" << nd << " Nsl=" << nsl << " Smartless=" << sma << " "
                                  << lv->GetName() << " Region: " << rname;
       ++nvox;
     }
   }
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMT: nLV=" << numLV << " NlvVox=" << nvox << " Nslices=" << nslice;
 }

◆ Connect()

void RunManagerMT::Connect ( RunAction * runAction )

Definition at line 282 of file RunManagerMT.cc.

References SimActivityRegistry::beginOfRunSignal_, sim_act::Signaler< T >::connect(), SimActivityRegistry::endOfRunSignal_, RunAction::m_beginOfRunSignal, RunAction::m_endOfRunSignal, and m_registry.

Referenced by SimRunInterface::Connect(), and initializeUserActions().

                                                {
   runAction->m_beginOfRunSignal.connect(m_registry.beginOfRunSignal_);
   runAction->m_endOfRunSignal.connect(m_registry.endOfRunSignal_);
 }

◆ G4Commands()

const std::vector<std::string>& RunManagerMT::G4Commands ( ) const

inline

Definition at line 74 of file RunManagerMT.h.

References m_G4Commands.

Referenced by RunManagerMTWorker::initializeG4().

74 { return m_G4Commands; }

RunManagerMT::m_G4Commands

std::vector< std::string > m_G4Commands

Definition: RunManagerMT.h:106

◆ initG4()

void RunManagerMT::initG4	(	const DDCompactView *	pDD,
		const cms::DDCompactView *	pDD4hep,
		const HepPDT::ParticleDataTable *	fPDGTable
	)

Definition at line 98 of file RunManagerMT.cc.

References RunAction::BeginOfRunAction(), RPCNoise_example::check, checkVoxels(), mps_setup::cmd, mps_check::command, beamerCreator::create(), SimActivityRegistry::dddWorldSignal_, DeadROC_duringRun::dir, Exception, ecalTB2006H4_GenSimDigiReco_cfg::G4cout, get, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), recoMuon::in, initializeUserActions(), m_catalog, m_check, m_currentRun, m_G4Commands, m_g4overlap, m_kernel, m_managerInitialized, m_p, m_physicsList, m_PhysicsTablesDir, m_pPhysics, m_registry, m_RestorePhysicsTables, m_stateManager, m_StorePhysicsTables, m_UIsession, m_userRunAction, m_world, SiStripPI::max, groupFilesInBlocks::nn, FSQDQM_cfi::pvs, setupVoxels(), AlCaHLTBitMon_QueryRunRegistry::string, and world().

                                                                     {
   if (m_managerInitialized) {
     edm::LogWarning("SimG4CoreApplication") << "RunManagerMT::initG4 was already done - exit";
     return;
   }
   bool geoFromDD4hep = m_p.getParameter<bool>("g4GeometryDD4hepSource");
   bool cuts = m_pPhysics.getParameter<bool>("CutsPerRegion");
   bool protonCut = m_pPhysics.getParameter<bool>("CutsOnProton");
   int verb = m_pPhysics.getUntrackedParameter<int>("Verbosity", 0);
   int stepverb = m_p.getUntrackedParameter<int>("SteppingVerbosity", 0);
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMT: start initialising of geometry DD4hep: " << geoFromDD4hep << "\n"
       << "              cutsPerRegion: " << cuts << " cutForProton: " << protonCut << "\n"
       << "              G4 verbosity: " << verb;
 
   G4Timer timer;
   timer.Start();
 
   G4UImanager::GetUIpointer()->SetCoutDestination(m_UIsession);
   G4UImanager::GetUIpointer()->SetMasterUIManager(true);
 
   m_world = std::make_unique<DDDWorld>(pDD, pDD4hep, m_catalog, verb, cuts, protonCut);
   G4VPhysicalVolume* world = m_world.get()->GetWorldVolume();
 
   m_kernel->SetVerboseLevel(verb);
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMT: Define cuts: " << cuts << " Geant4 run manager verbosity: " << verb;
 
   const G4RegionStore* regStore = G4RegionStore::GetInstance();
   const G4PhysicalVolumeStore* pvs = G4PhysicalVolumeStore::GetInstance();
   const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
   unsigned int numPV = pvs->size();
   unsigned int numLV = lvs->size();
   unsigned int nn = regStore->size();
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMT: " << numPV << " physical volumes; " << numLV << " logical volumes; " << nn << " regions.";
 
   if (m_check) {
     m_kernel->SetVerboseLevel(2);
   }
   m_kernel->DefineWorldVolume(world, true);
   m_registry.dddWorldSignal_(m_world.get());
   m_stateManager->SetNewState(G4State_PreInit);
 
   // Create physics list
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT: create PhysicsList";
 
   std::unique_ptr<PhysicsListMakerBase> physicsMaker(
       PhysicsListFactory::get()->create(m_pPhysics.getParameter<std::string>("type")));
   if (physicsMaker.get() == nullptr) {
     throw cms::Exception("Configuration") << "Unable to find the Physics list requested";
   }
   m_physicsList = physicsMaker->make(m_pPhysics, m_registry);
 
   PhysicsList* phys = m_physicsList.get();
   if (phys == nullptr) {
     throw cms::Exception("Configuration") << "Physics list construction failed!";
   }
   if (stepverb > 0) {
     verb = std::max(verb, 1);
   }
   G4HadronicParameters::Instance()->SetVerboseLevel(verb);
   G4EmParameters::Instance()->SetVerbose(verb);
   G4EmParameters::Instance()->SetWorkerVerbose(std::max(verb - 1, 0));
 
   // exotic particle physics
   double monopoleMass = m_pPhysics.getUntrackedParameter<double>("MonopoleMass", 0);
   if (monopoleMass > 0.0) {
     phys->RegisterPhysics(new CMSMonopolePhysics(fPDGTable, m_pPhysics));
   }
   bool exotica = m_pPhysics.getUntrackedParameter<bool>("ExoticaTransport", false);
   if (exotica) {
     CMSExoticaPhysics exo(phys, m_pPhysics);
   }
 
   // adding GFlash, Russian Roulette for eletrons and gamma,
   // step limiters on top of any Physics Lists
   phys->RegisterPhysics(new ParametrisedEMPhysics("EMoptions", m_pPhysics));
 
   if (m_RestorePhysicsTables) {
     m_physicsList->SetPhysicsTableRetrieved(m_PhysicsTablesDir);
   }
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT: start initialisation of PhysicsList for master";
 
   m_physicsList->SetDefaultCutValue(m_pPhysics.getParameter<double>("DefaultCutValue") * CLHEP::cm);
   m_physicsList->SetCutsWithDefault();
   m_kernel->SetPhysics(phys);
 
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT: PhysicsList and cuts are defined";
 
   // Enable couple transportation
   bool scorer = m_p.getParameter<bool>("UseCommandBaseScorer");
   if (scorer) {
     G4ScoringManager* scManager = G4ScoringManager::GetScoringManager();
     scManager->SetVerboseLevel(1);
   }
   // Geant4 UI commands before initialisation of physics
   if (!m_G4Commands.empty()) {
     edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT: Requested UI commands: ";
     for (const std::string& command : m_G4Commands) {
       edm::LogVerbatim("SimG4CoreApplication") << "    " << command;
       G4UImanager::GetUIpointer()->ApplyCommand(command);
     }
   }
 
   setupVoxels();
 
   m_stateManager->SetNewState(G4State_Init);
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT: G4State is Init";
   m_kernel->InitializePhysics();
   if (verb > 0) {
     G4EmParameters::Instance()->Dump();
   }
   m_kernel->SetUpDecayChannels();
 
   if (m_kernel->RunInitialization()) {
     m_managerInitialized = true;
   } else {
     throw cms::Exception("LogicError") << "G4RunManagerKernel initialization failed!";
   }
 
   if (m_check) {
     checkVoxels();
   }
 
   if (m_StorePhysicsTables) {
     std::ostringstream dir;
     dir << m_PhysicsTablesDir << '\0';
     std::string cmd = std::string("/control/shell mkdir -p ") + m_PhysicsTablesDir;
     if (!std::ifstream(dir.str().c_str(), std::ios::in))
       G4UImanager::GetUIpointer()->ApplyCommand(cmd);
     m_physicsList->StorePhysicsTable(m_PhysicsTablesDir);
   }
   // Appload nuclear level data up to Z=84
   G4NuclearLevelData::GetInstance()->UploadNuclearLevelData(84);
 
   if (verb > 1) {
     m_physicsList->DumpCutValuesTable();
   }
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMT: Physics is initilized, now initialise user actions, verb=" << verb;
 
   initializeUserActions();
 
   // geometry dump
   auto writeFile = m_p.getUntrackedParameter<std::string>("FileNameGDML", "");
   if (!writeFile.empty()) {
     G4GDMLParser gdml;
     gdml.SetRegionExport(true);
     gdml.SetEnergyCutsExport(true);
     gdml.Write(writeFile, m_world->GetWorldVolume(), true);
   }
 
   // G4Region dump file name
   auto regionFile = m_p.getUntrackedParameter<std::string>("FileNameRegions", "");
 
   // Geometry checks
   if (m_check || !regionFile.empty()) {
     CMSG4CheckOverlap check(m_g4overlap, regionFile, m_UIsession, world);
   }
 
   m_stateManager->SetNewState(G4State_PreInit);
   G4HadronicParameters::Instance()->SetVerboseLevel(std::max(verb - 1, 0));
 
   // If the Geant4 particle table is needed, decomment the lines below
   //
   //G4ParticleTable::GetParticleTable()->DumpTable("ALL");
   //
   m_stateManager->SetNewState(G4State_GeomClosed);
   m_currentRun = new G4Run();
   m_userRunAction->BeginOfRunAction(m_currentRun);
   timer.Stop();
   G4cout.precision(4);
   G4cout << "RunManagerMT: initG4 done " << timer << G4endl;
 }

◆ initializeUserActions()

void RunManagerMT::initializeUserActions ( )

Definition at line 276 of file RunManagerMT.cc.

References Connect(), m_pRunAction, m_runInterface, m_userRunAction, and g4SimHits_cfi::RunAction.

Referenced by initG4().

                                          {
   m_runInterface = std::make_unique<SimRunInterface>(this, true);
   m_userRunAction = new RunAction(m_pRunAction, m_runInterface.get(), true);
   Connect(m_userRunAction);
 }

◆ physicsListForWorker()

PhysicsList* RunManagerMT::physicsListForWorker ( ) const

inline

Definition at line 78 of file RunManagerMT.h.

References m_physicsList.

Referenced by RunManagerMTWorker::initializeG4().

78 { return m_physicsList.get(); }

RunManagerMT::m_physicsList

std::unique_ptr< PhysicsList > m_physicsList

Definition: RunManagerMT.h:90

◆ setupVoxels()

void RunManagerMT::setupVoxels ( )

private

Definition at line 336 of file RunManagerMT.cc.

References fastSimProducer_cff::density, edm::ParameterSet::getParameter(), mps_fire::i, createfilelist::int, m_p, dqmiodumpmetadata::n, EgHLTOffHistBins_cfi::nr, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by initG4().

                                {
   double density = m_p.getParameter<double>("DefaultVoxelDensity");
   std::vector<std::string> rnames = m_p.getParameter<std::vector<std::string> >("VoxelRegions");
   std::vector<double> rdensities = m_p.getParameter<std::vector<double> >("VoxelDensityPerRegion");
   int nr = 0;
   std::size_t n = rnames.size();
   if (n == rdensities.size()) {
     nr = (int)n;
   }
   const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
   for (auto& lv : *lvs) {
     double den = density;
     if (0 < nr) {
       std::string nam = lv->GetRegion()->GetName();
       for (int i = 0; i < nr; ++i) {
         if (nam == rnames[i]) {
           den = rdensities[i];
           break;
         }
       }
     }
     lv->SetSmartless(den);
   }
   edm::LogVerbatim("SimG4CoreApplication")
       << "RunManagerMT: default voxel density=" << density << "; number of regions with special density " << nr;
 }

◆ stopG4()

void RunManagerMT::stopG4 ( )

Definition at line 287 of file RunManagerMT.cc.

References m_runTerminated, m_stateManager, and terminateRun().

                           {
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT::stopG4";
   G4GeometryManager::GetInstance()->OpenGeometry();
   m_stateManager->SetNewState(G4State_Quit);
   if (!m_runTerminated) {
     terminateRun();
   }
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT::stopG4 done";
 }

◆ terminateRun()

void RunManagerMT::terminateRun ( )

private

Definition at line 297 of file RunManagerMT.cc.

References RunAction::EndOfRunAction(), m_currentRun, m_kernel, m_runTerminated, and m_userRunAction.

Referenced by stopG4().

                                 {
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT::terminateRun";
   if (nullptr != m_userRunAction) {
     m_userRunAction->EndOfRunAction(m_currentRun);
     delete m_userRunAction;
     m_userRunAction = nullptr;
   }
   if (!m_runTerminated) {
     m_kernel->RunTermination();
   }
   m_runTerminated = true;
   edm::LogVerbatim("SimG4CoreApplication") << "RunManagerMT::terminateRun done";
 }

◆ world()

const DDDWorld& RunManagerMT::world ( ) const

inline

Definition at line 70 of file RunManagerMT.h.

References m_world.

Referenced by initG4(), and RunManagerMTWorker::initializeG4().

70 { return *m_world; }

RunManagerMT::m_world

std::unique_ptr< DDDWorld > m_world

Definition: RunManagerMT.h:109

Friends And Related Function Documentation

◆ RunManagerMTWorker

friend class RunManagerMTWorker

friend

Definition at line 52 of file RunManagerMT.h.

Member Data Documentation

◆ m_catalog

SensitiveDetectorCatalog RunManagerMT::m_catalog

private

Definition at line 111 of file RunManagerMT.h.

Referenced by catalog(), and initG4().

◆ m_check

bool RunManagerMT::m_check

private

Definition at line 102 of file RunManagerMT.h.

Referenced by initG4(), and RunManagerMT().

◆ m_currentRun

G4Run* RunManagerMT::m_currentRun

private

Definition at line 94 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and terminateRun().

◆ m_G4Commands

std::vector<std::string> RunManagerMT::m_G4Commands

private

Definition at line 106 of file RunManagerMT.h.

Referenced by G4Commands(), and initG4().

◆ m_g4overlap

edm::ParameterSet RunManagerMT::m_g4overlap

private

Definition at line 105 of file RunManagerMT.h.

Referenced by initG4().

◆ m_kernel

G4MTRunManagerKernel* RunManagerMT::m_kernel

private

Definition at line 87 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and terminateRun().

◆ m_managerInitialized

bool RunManagerMT::m_managerInitialized

private

Definition at line 91 of file RunManagerMT.h.

Referenced by initG4().

◆ m_p

edm::ParameterSet RunManagerMT::m_p

private

Definition at line 107 of file RunManagerMT.h.

Referenced by initG4(), and setupVoxels().

◆ m_physicsList

std::unique_ptr<PhysicsList> RunManagerMT::m_physicsList

private

Definition at line 90 of file RunManagerMT.h.

Referenced by initG4(), physicsListForWorker(), and RunManagerMT().

◆ m_PhysicsTablesDir

const std::string RunManagerMT::m_PhysicsTablesDir

private

Definition at line 99 of file RunManagerMT.h.

Referenced by initG4().

◆ m_pPhysics

edm::ParameterSet RunManagerMT::m_pPhysics

private

Definition at line 103 of file RunManagerMT.h.

Referenced by initG4().

◆ m_pRunAction

edm::ParameterSet RunManagerMT::m_pRunAction

private

Definition at line 104 of file RunManagerMT.h.

Referenced by initializeUserActions().

◆ m_registry

SimActivityRegistry RunManagerMT::m_registry

private

Definition at line 110 of file RunManagerMT.h.

Referenced by Connect(), and initG4().

◆ m_RestorePhysicsTables

bool RunManagerMT::m_RestorePhysicsTables

private

Definition at line 101 of file RunManagerMT.h.

Referenced by initG4().

◆ m_runInterface

std::unique_ptr<SimRunInterface> RunManagerMT::m_runInterface

private

Definition at line 97 of file RunManagerMT.h.

Referenced by initializeUserActions(), and RunManagerMT().

◆ m_runTerminated

bool RunManagerMT::m_runTerminated

private

Definition at line 92 of file RunManagerMT.h.

Referenced by stopG4(), and terminateRun().

◆ m_stateManager

G4StateManager* RunManagerMT::m_stateManager

private

Definition at line 95 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and stopG4().

◆ m_StorePhysicsTables

bool RunManagerMT::m_StorePhysicsTables

private

Definition at line 100 of file RunManagerMT.h.

Referenced by initG4().

◆ m_UIsession

CustomUIsession* RunManagerMT::m_UIsession

private

Definition at line 89 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and ~RunManagerMT().

◆ m_userRunAction

RunAction* RunManagerMT::m_userRunAction

private

Definition at line 93 of file RunManagerMT.h.

Referenced by initG4(), initializeUserActions(), RunManagerMT(), and terminateRun().

◆ m_world

std::unique_ptr<DDDWorld> RunManagerMT::m_world

private

Definition at line 109 of file RunManagerMT.h.

Referenced by initG4(), RunManagerMT(), and world().

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ RunManagerMT()

◆ ~RunManagerMT()

Member Function Documentation

◆ catalog()

◆ checkVoxels()

◆ Connect()

◆ G4Commands()

◆ initG4()

◆ initializeUserActions()

◆ physicsListForWorker()

◆ setupVoxels()

◆ stopG4()

◆ terminateRun()

◆ world()

Friends And Related Function Documentation

◆ RunManagerMTWorker

Member Data Documentation

◆ m_catalog

◆ m_check

◆ m_currentRun

◆ m_G4Commands

◆ m_g4overlap

◆ m_kernel

◆ m_managerInitialized

◆ m_p

◆ m_physicsList

◆ m_PhysicsTablesDir

◆ m_pPhysics

◆ m_pRunAction

◆ m_registry

◆ m_RestorePhysicsTables

◆ m_runInterface

◆ m_runTerminated

◆ m_stateManager

◆ m_StorePhysicsTables

◆ m_UIsession

◆ m_userRunAction

◆ m_world