#include <G4RunManagerKernel.hh>

Inheritance diagram for G4RunManagerKernel:

Public Types
enum	RMKType { sequentialRMK , masterRMK , workerRMK }

Public Member Functions
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=nullptr) const

	G4RunManagerKernel ()

void	GeometryHasBeenModified ()

G4VPhysicalVolume *	GetCurrentWorld () const

G4EventManager *	GetEventManager () const

G4int	GetNumberOfParallelWorld () const

G4int	GetNumberOfStaticAllocators () const

G4VUserPhysicsList *	GetPhysicsList () const

G4PrimaryTransformer *	GetPrimaryTransformer () const

G4StackManager *	GetStackManager () const

G4TrackingManager *	GetTrackingManager () const

const G4String &	GetVersionString () const

void	InitializePhysics ()

void	PhysicsHasBeenModified ()

G4bool	RunInitialization (G4bool fakeRun=false)

void	RunTermination ()

void	SetGeometryToBeOptimized (G4bool vl)

void	SetNumberOfParallelWorld (G4int i)

void	SetPhysics (G4VUserPhysicsList *uPhys)

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

void	SetVerboseLevel (G4int vl)

void	UpdateRegion ()

void	WorkerDefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)

void	WorkerUpdateWorldVolume ()

virtual	~G4RunManagerKernel ()

Static Public Member Functions
static G4RunManagerKernel *	GetRunManagerKernel ()

Protected Member Functions
void	BuildPhysicsTables (G4bool fakeRun)

void	CheckRegions ()

	G4RunManagerKernel (RMKType rmkType)

void	PropagateGenericIonID ()

void	ResetNavigator ()

void	SetupDefaultRegion ()

void	SetupPhysics ()

virtual void	SetupShadowProcess () const

Protected Attributes
G4Region *	defaultRegion = nullptr

G4Region *	defaultRegionForParallelWorld = nullptr

G4bool	geometryNeedsToBeClosed = true

RMKType	runManagerKernelType

Private Member Functions
void	CheckRegularGeometry ()

G4bool	ConfirmCoupledTransportation ()

void	SetScoreSplitter ()

Private Attributes
G4VPhysicalVolume *	currentWorld = nullptr

G4ExceptionHandler *	defaultExceptionHandler = nullptr

G4EventManager *	eventManager = nullptr

G4bool	geometryInitialized = false

G4bool	geometryToBeOptimized = true

G4int	numberOfParallelWorld = 0

G4int	numberOfStaticAllocators = 0

G4bool	physicsInitialized = false

G4VUserPhysicsList *	physicsList = nullptr

G4bool	physicsNeedsToBeReBuilt = true

G4int	verboseLevel = 0

G4String	versionString = ""

Static Private Attributes
static G4ThreadLocal G4RunManagerKernel *	fRunManagerKernel = nullptr

Detailed Description

Definition at line 64 of file G4RunManagerKernel.hh.

Member Enumeration Documentation

◆ RMKType

enum G4RunManagerKernel::RMKType

Enumerator
sequentialRMK
masterRMK
workerRMK

Definition at line 176 of file G4RunManagerKernel.hh.

    {
      sequentialRMK,
      masterRMK,
      workerRMK
    };

Constructor & Destructor Documentation

◆ G4RunManagerKernel() [1/2]

G4RunManagerKernel::G4RunManagerKernel ( )

Definition at line 104 of file G4RunManagerKernel.cc.

{
  #ifdef G4FPE_DEBUG
    InvalidOperationDetection();
  #endif
 
  #ifdef G4BT_DEBUG
    auto _signals = G4GetEnv<std::string>("G4BACKTRACE", "");
    if(_signals.empty())
    {
      G4Backtrace::Enable();
    }
    else
    {
      G4Backtrace::Enable(_signals);
    }
  #endif
 
  G4AllocatorList* allocList = G4AllocatorList::GetAllocatorListIfExist();
  if(allocList != nullptr)
    numberOfStaticAllocators = allocList->Size();
 
  if(G4StateManager::GetStateManager()->GetExceptionHandler() == nullptr)
  {  
     defaultExceptionHandler = new G4ExceptionHandler();
  }
  if(fRunManagerKernel != nullptr)
  {
    G4Exception("G4RunManagerKernel::G4RunManagerKernel()", "Run0001",
                FatalException,
                "More than one G4RunManagerKernel is constructed.");
  }
  fRunManagerKernel = this;
 
  G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
  if(particleTable->entries() > 0)
  {
    // No particle should be registered beforehand
    G4ExceptionDescription ED;
    ED << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
    ED << " G4RunManagerKernel fatal exception" << G4endl;
    ED << "  -- Following particles have already been registered" << G4endl;
    ED << "     before G4RunManagerKernel is instantiated." << G4endl;
    for(G4int i = 0; i < particleTable->entries(); ++i)
    {
      ED << "     " << particleTable->GetParticle(i)->GetParticleName()
         << G4endl;
    }
    ED << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
    G4Exception("G4RunManagerKernel::G4RunManagerKernel()", "Run0002",
                FatalException, ED);
  }
 
  // construction of Geant4 kernel classes
  eventManager = new G4EventManager();
 
  defaultRegion = new G4Region("DefaultRegionForTheWorld");  // deleted by store
  defaultRegionForParallelWorld =
    new G4Region("DefaultRegionForParallelWorld");  // deleted by store
  defaultRegion->SetProductionCuts(
    G4ProductionCutsTable::GetProductionCutsTable()
      ->GetDefaultProductionCuts());
  defaultRegionForParallelWorld->SetProductionCuts(
    G4ProductionCutsTable::GetProductionCutsTable()
      ->GetDefaultProductionCuts());
 
  runManagerKernelType = sequentialRMK;
  // set the initial application state
  G4StateManager::GetStateManager()->SetNewState(G4State_PreInit);
 
  // version banner
  G4String vs   = G4Version;
  vs            = vs.substr(1, vs.size() - 2);
  versionString = " Geant4 version ";
  versionString += vs;
  versionString += "   ";
  versionString += G4Date;
  G4cout << G4endl
         << "**************************************************************"
         << G4endl << versionString << G4endl
         << "                       Copyright : Geant4 Collaboration" << G4endl
         << "                      References : NIM A 506 (2003), 250-303"
         << G4endl
         << "                                 : IEEE-TNS 53 (2006), 270-278"
         << G4endl
         << "                                 : NIM A 835 (2016), 186-225"
         << G4endl << "                             WWW : http://geant4.org/"
         << G4endl
         << "**************************************************************"
         << G4endl << G4endl;
}

References defaultExceptionHandler, defaultRegion, defaultRegionForParallelWorld, G4Backtrace::Enable(), G4ParticleTable::entries(), eventManager, FatalException, fRunManagerKernel, G4cout, G4Date, G4endl, G4Exception(), G4State_PreInit, G4Version, G4AllocatorList::GetAllocatorListIfExist(), G4ParticleTable::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), InvalidOperationDetection(), numberOfStaticAllocators, runManagerKernelType, sequentialRMK, G4StateManager::SetNewState(), G4Region::SetProductionCuts(), G4AllocatorList::Size(), and versionString.

◆ ~G4RunManagerKernel()

G4RunManagerKernel::~G4RunManagerKernel ( )

virtual

Definition at line 353 of file G4RunManagerKernel.cc.

{
  G4StateManager* pStateManager = G4StateManager::GetStateManager();
  // set the application state to the quite state
  if(pStateManager->GetCurrentState() != G4State_Quit)
  {
    if(verboseLevel > 0)
      G4cout << "G4 kernel has come to Quit state." << G4endl;
    pStateManager->SetNewState(G4State_Quit);
  }
 
  // open geometry for deletion
  G4GeometryManager::GetInstance()->OpenGeometry();
 
  // deletion of Geant4 kernel classes
  delete G4ParallelWorldProcessStore::GetInstanceIfExist();
  delete G4SDManager::GetSDMpointerIfExist();
  if(verboseLevel > 1)
    G4cout << "G4SDManager deleted." << G4endl;
  delete eventManager;
  if(verboseLevel > 1)
    G4cout << "EventManager deleted." << G4endl;
 
  G4UnitDefinition::ClearUnitsTable();
  if(verboseLevel > 1)
    G4cout << "Units table cleared." << G4endl;
 
  // deletion of path-finder field-manager store, geometry and transportation
  // manager
  delete G4PathFinder::GetInstanceIfExist();
  delete G4FieldManagerStore::GetInstanceIfExist();
  delete G4GeometryManager::GetInstanceIfExist();
  delete G4TransportationManager::GetInstanceIfExist();
  if(verboseLevel > 1)
    G4cout << "TransportationManager deleted." << G4endl;
 
  // deletion of navigation levels
  if(verboseLevel > 1)
    G4NavigationHistoryPool::GetInstance()->Print();
  delete G4NavigationHistoryPool::GetInstance();
 
  // deletion of G4RNGHelper singleton
  if(runManagerKernelType != workerRMK)
  {
    delete G4RNGHelper::GetInstanceIfExist();
    if(verboseLevel > 1)
      G4cout << "G4RNGHelper object is deleted." << G4endl;
  }
 
  // deletion of allocators
  G4AllocatorList* allocList = G4AllocatorList::GetAllocatorListIfExist();
  if(allocList)
  {
    allocList->Destroy(numberOfStaticAllocators, verboseLevel);
    delete allocList;
    if(verboseLevel > 1)
      G4cout << "G4Allocator objects are deleted." << G4endl;
  }
 
  G4UImanager* pUImanager = G4UImanager::GetUIpointer();
  if((runManagerKernelType == workerRMK) && (verboseLevel > 0))
  {
    G4cout << "Thread-local UImanager is to be deleted." << G4endl
           << "There should not be any thread-local G4cout/G4cerr hereafter."
           << G4endl;
    verboseLevel = 0;
  }
  delete pUImanager;
  if(verboseLevel > 1)
    G4cout << "UImanager deleted." << G4endl;
 
  delete pStateManager;
  if(verboseLevel > 1)
    G4cout << "StateManager deleted." << G4endl;
  delete defaultExceptionHandler;
  if(verboseLevel > 0)
    G4cout << "RunManagerKernel is deleted. Good bye :)" << G4endl;
  fRunManagerKernel = nullptr;
}

References G4UnitDefinition::ClearUnitsTable(), defaultExceptionHandler, G4AllocatorList::Destroy(), eventManager, fRunManagerKernel, G4cout, G4endl, G4State_Quit, G4AllocatorList::GetAllocatorListIfExist(), G4StateManager::GetCurrentState(), G4GeometryManager::GetInstance(), G4NavigationHistoryPool::GetInstance(), G4FieldManagerStore::GetInstanceIfExist(), G4GeometryManager::GetInstanceIfExist(), G4PathFinder::GetInstanceIfExist(), G4TransportationManager::GetInstanceIfExist(), G4ParallelWorldProcessStore::GetInstanceIfExist(), G4TemplateRNGHelper< T >::GetInstanceIfExist(), G4SDManager::GetSDMpointerIfExist(), G4StateManager::GetStateManager(), G4UImanager::GetUIpointer(), numberOfStaticAllocators, G4GeometryManager::OpenGeometry(), G4NavigationHistoryPool::Print(), runManagerKernelType, G4StateManager::SetNewState(), verboseLevel, and workerRMK.

◆ G4RunManagerKernel() [2/2]

G4RunManagerKernel::G4RunManagerKernel ( RMKType rmkType )

protected

Definition at line 197 of file G4RunManagerKernel.cc.

{
  // This version of the constructor should never be called in sequential mode!
  #ifndef G4MULTITHREADED
    G4ExceptionDescription msg;
    msg << "Geant4 code is compiled without multi-threading support "
           "(-DG4MULTITHREADED is set to off).";
    msg << " This type of RunManagerKernel can only be used in mult-threaded "
           "applications.";
    G4Exception("G4RunManagerKernel::G4RunManagerKernel(G4bool)", "Run0105",
                FatalException, msg);
  #endif
 
  #ifdef G4FPE_DEBUG
    if(G4Threading::IsMasterThread())
    {
      InvalidOperationDetection();
    }
  #endif
 
  #ifdef G4BT_DEBUG
    auto _signals = G4GetEnv<std::string>("G4BACKTRACE", "");
    if(_signals.empty())
    {
      G4Backtrace::Enable();
    }
    else
    {
      G4Backtrace::Enable(_signals);
    }
  #endif
 
  if(G4StateManager::GetStateManager()->GetExceptionHandler() == nullptr)
  {
     defaultExceptionHandler = new G4ExceptionHandler();
  }
 
  if(fRunManagerKernel != nullptr)
  {
    G4Exception("G4RunManagerKernel::G4RunManagerKernel()", "Run0001",
                FatalException,
                "More than one G4RunManagerKernel is constructed.");
  }
  fRunManagerKernel = this;
  // construction of Geant4 kernel classes
  eventManager = new G4EventManager();
 
  switch(rmkType)
  {
    case masterRMK:
      // Master thread behvior
      defaultRegion =
        new G4Region("DefaultRegionForTheWorld");  // deleted by store
      defaultRegionForParallelWorld =
        new G4Region("DefaultRegionForParallelWorld");  // deleted by store
      defaultRegion->SetProductionCuts(
        G4ProductionCutsTable::GetProductionCutsTable()
          ->GetDefaultProductionCuts());
      defaultRegionForParallelWorld->SetProductionCuts(
        G4ProductionCutsTable::GetProductionCutsTable()
          ->GetDefaultProductionCuts());
      break;
    case workerRMK:
      // Worker thread behavior
      defaultRegion = G4RegionStore::GetInstance()->GetRegion(
        "DefaultRegionForTheWorld", true);
      defaultRegionForParallelWorld = G4RegionStore::GetInstance()->GetRegion(
        "DefaultRegionForParallelWorld", true);
      break;
    default:
      defaultRegion                 = nullptr;
      defaultRegionForParallelWorld = nullptr;
      G4ExceptionDescription msgx;
      msgx
        << " This type of RunManagerKernel can only be used in mult-threaded "
           "applications.";
      G4Exception("G4RunManagerKernel::G4RunManagerKernel(G4bool)", "Run0106",
                  FatalException, msgx);
  }
  runManagerKernelType = rmkType;
 
  // set the initial application state
  G4StateManager::GetStateManager()->SetNewState(G4State_PreInit);
 
  // version banner
  G4String vs = G4Version;
  vs          = vs.substr(1, vs.size() - 2);
  switch(rmkType)
  {
    case masterRMK:
      versionString = " Geant4 version ";
      versionString += vs;
      versionString += "   ";
      versionString += G4Date;
      G4cout << G4endl
             << "**************************************************************"
             << G4endl << versionString << G4endl
             << "  << in Multi-threaded mode >> " << G4endl
             << "                       Copyright : Geant4 Collaboration"
             << G4endl
             << "                      References : NIM A 506 (2003), 250-303"
             << G4endl
             << "                                 : IEEE-TNS 53 (2006), 270-278"
             << G4endl
             << "                                 : NIM A 835 (2016), 186-225"
             << G4endl
             << "                             WWW : http://geant4.org/"
             << G4endl
             << "**************************************************************"
             << G4endl << G4endl;
      break;
    default:
      if(verboseLevel)
      {
        versionString = " Local thread RunManagerKernel version ";
        versionString += vs;
        G4cout
          << G4endl
          << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
             "^^^^^^^^^"
          << G4endl << versionString << G4endl
          << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
             "^^^^^^^^^"
          << G4endl << G4endl;
      }
  }
 
  #ifdef G4MULTITHREADED
    G4UnitDefinition::GetUnitsTable().Synchronize();
  #endif
}

References defaultExceptionHandler, defaultRegion, defaultRegionForParallelWorld, G4Backtrace::Enable(), eventManager, FatalException, fRunManagerKernel, G4cout, G4Date, G4endl, G4Exception(), G4State_PreInit, G4Version, G4RegionStore::GetInstance(), G4ProductionCutsTable::GetProductionCutsTable(), G4RegionStore::GetRegion(), G4StateManager::GetStateManager(), G4UnitDefinition::GetUnitsTable(), InvalidOperationDetection(), G4Threading::IsMasterThread(), masterRMK, runManagerKernelType, G4StateManager::SetNewState(), G4Region::SetProductionCuts(), verboseLevel, versionString, and workerRMK.

Member Function Documentation

◆ BuildPhysicsTables()

void G4RunManagerKernel::BuildPhysicsTables ( G4bool fakeRun )

protected

Definition at line 895 of file G4RunManagerKernel.cc.

{
  if(G4ProductionCutsTable::GetProductionCutsTable()->IsModified() ||
     physicsNeedsToBeReBuilt)
  {
  #ifdef G4MULTITHREADED
    if(runManagerKernelType == masterRMK)
    {
      // make sure workers also rebuild physics tables
      G4UImanager* pUImanager = G4UImanager::GetUIpointer();
      pUImanager->ApplyCommand("/run/physicsModified");
    }
  #endif
    physicsList->BuildPhysicsTable();
    physicsNeedsToBeReBuilt = false;
  }
 
  if(!fakeRun && verboseLevel > 1)
    DumpRegion();
  if(!fakeRun && verboseLevel > 0)
    physicsList->DumpCutValuesTable();
  if(!fakeRun)
    physicsList->DumpCutValuesTableIfRequested();
}

References G4UImanager::ApplyCommand(), G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::DumpCutValuesTable(), G4VUserPhysicsList::DumpCutValuesTableIfRequested(), DumpRegion(), G4ProductionCutsTable::GetProductionCutsTable(), G4UImanager::GetUIpointer(), masterRMK, physicsList, physicsNeedsToBeReBuilt, runManagerKernelType, and verboseLevel.

Referenced by RunInitialization().

◆ CheckRegions()

void G4RunManagerKernel::CheckRegions ( )

protected

Definition at line 922 of file G4RunManagerKernel.cc.

{
  G4TransportationManager* transM =
    G4TransportationManager::GetTransportationManager();
  std::size_t nWorlds = transM->GetNoWorlds();
  std::vector<G4VPhysicalVolume*>::iterator wItr;
  for(std::size_t i = 0; i < G4RegionStore::GetInstance()->size(); ++i)
  {
    G4Region* region = (*(G4RegionStore::GetInstance()))[i];
 
    // Let each region have a pointer to the world volume where it belongs to.
    // G4Region::SetWorld() checks if the region belongs to the given world and
    // set it only if it does. Thus, here we go through all the registered world
    // volumes.
    region->SetWorld(nullptr);  // reset
    region->UsedInMassGeometry(false);
    region->UsedInParallelGeometry(false);
    wItr = transM->GetWorldsIterator();
    for(std::size_t iw = 0; iw < nWorlds; ++iw)
    {
      if(region->BelongsTo(*wItr))
      {
        if(*wItr == currentWorld)
        {
          region->UsedInMassGeometry(true);
        }
        else
        {
          region->UsedInParallelGeometry(true);
        }
      }
      region->SetWorld(*wItr);
      ++wItr;
    }
 
    G4ProductionCuts* cuts = region->GetProductionCuts();
    if(cuts == nullptr)
    {
      if(region->IsInMassGeometry() && verboseLevel > 0)
      {
        G4cout << "Warning : Region <" << region->GetName()
               << "> does not have specific production cuts," << G4endl
               << "even though it appears in the current tracking world."
               << G4endl;
        G4cout << "Default cuts are used for this region." << G4endl;
      }
 
      if(region->IsInMassGeometry() || region->IsInParallelGeometry())
      {
        region->SetProductionCuts(
          G4ProductionCutsTable::GetProductionCutsTable()
            ->GetDefaultProductionCuts());
      }
    }
  }
 
  //
  // If a parallel world has no region, set default region for parallel world
  //
 
  wItr = transM->GetWorldsIterator();
  for(std::size_t iw = 0; iw < nWorlds; ++iw)
  {
    if(*wItr != currentWorld)
    {
      G4LogicalVolume* pwLogical = (*wItr)->GetLogicalVolume();
      if(pwLogical->GetRegion() == nullptr)
      {
        pwLogical->SetRegion(defaultRegionForParallelWorld);
        defaultRegionForParallelWorld->AddRootLogicalVolume(pwLogical);
      }
    }
    ++wItr;
  }
}

References G4Region::AddRootLogicalVolume(), G4Region::BelongsTo(), currentWorld, defaultRegionForParallelWorld, G4cout, G4endl, G4ProductionCutsTable::GetDefaultProductionCuts(), G4RegionStore::GetInstance(), G4Region::GetName(), G4TransportationManager::GetNoWorlds(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4LogicalVolume::GetRegion(), G4TransportationManager::GetTransportationManager(), G4TransportationManager::GetWorldsIterator(), G4Region::IsInMassGeometry(), G4Region::IsInParallelGeometry(), G4Region::SetProductionCuts(), G4LogicalVolume::SetRegion(), G4Region::SetWorld(), G4Region::UsedInMassGeometry(), G4Region::UsedInParallelGeometry(), and verboseLevel.

Referenced by InitializePhysics(), and UpdateRegion().

◆ CheckRegularGeometry()

void G4RunManagerKernel::CheckRegularGeometry ( )

private

Definition at line 1090 of file G4RunManagerKernel.cc.

{
  G4LogicalVolumeStore* store = G4LogicalVolumeStore::GetInstance();
  for(auto pos = store->cbegin(); pos != store->cend(); ++pos)
  {
    if((*pos) && ((*pos)->GetNoDaughters() == 1))
    {
      if((*pos)->GetDaughter(0)->IsRegularStructure())
      {
        SetScoreSplitter();
        return;
      }
    }
  }
}

References G4LogicalVolumeStore::GetInstance(), pos, and SetScoreSplitter().

Referenced by RunInitialization().

◆ ConfirmCoupledTransportation()

G4bool G4RunManagerKernel::ConfirmCoupledTransportation ( )

private

Definition at line 1107 of file G4RunManagerKernel.cc.

{
  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
  auto theParticleIterator = theParticleTable->GetIterator();
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* pd = theParticleIterator->value();
    G4ProcessManager* pm     = pd->GetProcessManager();
    if(pm)
    {
      G4ProcessVector* pv = pm->GetAlongStepProcessVector(typeDoIt);
      G4VProcess* p       = (*pv)[0];
      return ((p->GetProcessName()) == "CoupledTransportation");
    }
  }
  return false;
}

References G4ProcessManager::GetAlongStepProcessVector(), G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), theParticleIterator, and typeDoIt.

◆ DefineWorldVolume()

void G4RunManagerKernel::DefineWorldVolume	(	G4VPhysicalVolume *	worldVol,
		G4bool	topologyIsChanged = `true`
	)

Definition at line 520 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
 
  if(currentState != G4State_Init)
  {
    if(!(currentState == G4State_Idle || currentState == G4State_PreInit))
    {
      G4cout << "Current application state is "
             << stateManager->GetStateString(currentState) << G4endl;
      G4Exception("G4RunManagerKernel::DefineWorldVolume",
                  "DefineWorldVolumeAtIncorrectState", FatalException,
                  "Geant4 kernel is not Init state : Method ignored.");
      return;
    }
    else
    {
      stateManager->SetNewState(G4State_Init);
    }
  }
 
  // The world volume MUST NOT have a region defined by the user
  if(worldVol->GetLogicalVolume()->GetRegion() != nullptr)
  {
    if(worldVol->GetLogicalVolume()->GetRegion() != defaultRegion)
    {
      G4ExceptionDescription ED;
      ED << "The world volume has a user-defined region <"
         << worldVol->GetLogicalVolume()->GetRegion()->GetName() << ">."
         << G4endl;
      ED << "World would have a default region assigned by RunManagerKernel."
         << G4endl;
      G4Exception("G4RunManager::DefineWorldVolume", "Run0004", FatalException,
                  ED);
    }
  }
 
  SetupDefaultRegion();
 
  // Accept the world volume
  currentWorld = worldVol;
 
  // Set the default region to the world
 
  G4LogicalVolume* worldLog = currentWorld->GetLogicalVolume();
  worldLog->SetRegion(defaultRegion);
  defaultRegion->AddRootLogicalVolume(worldLog);
  if(verboseLevel > 1)
    G4cout << worldLog->GetName() << " is registered to the default region."
           << G4endl;
 
  // Set the world volume, notify the Navigator and reset its state
  G4TransportationManager::GetTransportationManager()
    ->SetWorldForTracking(currentWorld);
  if(topologyIsChanged)
    geometryNeedsToBeClosed = true;
 
  // Notify the VisManager as well
  if(G4Threading::IsMasterThread())
  {
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if(pVVisManager != nullptr)
      pVVisManager->GeometryHasChanged();
  }
 
  geometryInitialized = true;
  stateManager->SetNewState(currentState);
  if(physicsInitialized && currentState != G4State_Idle)
  {
    stateManager->SetNewState(G4State_Idle);
  }
}

References G4Region::AddRootLogicalVolume(), currentWorld, defaultRegion, FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4VVisManager::GeometryHasChanged(), geometryInitialized, geometryNeedsToBeClosed, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4Region::GetName(), G4LogicalVolume::GetRegion(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), G4TransportationManager::GetTransportationManager(), G4Threading::IsMasterThread(), physicsInitialized, G4StateManager::SetNewState(), G4LogicalVolume::SetRegion(), SetupDefaultRegion(), G4TransportationManager::SetWorldForTracking(), and verboseLevel.

Referenced by G4RunManager::DefineWorldVolume(), G4ErrorRunManagerHelper::InitializeGeometry(), and G4RunManager::InitializeGeometry().

◆ DumpRegion() [1/2]

void G4RunManagerKernel::DumpRegion ( const G4String & rname ) const

Definition at line 999 of file G4RunManagerKernel.cc.

{
  G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
  if(region != nullptr)
    DumpRegion(region);
}

References DumpRegion(), G4RegionStore::GetInstance(), and G4RegionStore::GetRegion().

Referenced by BuildPhysicsTables(), G4RunManager::DumpRegion(), and DumpRegion().

◆ DumpRegion() [2/2]

void G4RunManagerKernel::DumpRegion ( G4Region * region = nullptr ) const

Definition at line 1007 of file G4RunManagerKernel.cc.

{
  if(region == nullptr)
  {
    for(std::size_t i = 0; i < G4RegionStore::GetInstance()->size(); ++i)
    {
      DumpRegion((*(G4RegionStore::GetInstance()))[i]);
    }
  }
  else
  {
    if(G4Threading::IsWorkerThread())
      return;
    G4cout << G4endl;
    G4cout << "Region <" << region->GetName() << "> -- ";
    if(region->GetWorldPhysical())
    {
      G4cout << " -- appears in <" << region->GetWorldPhysical()->GetName()
             << "> world volume";
    }
    else
    {
      G4cout << " -- is not associated to any world.";
    }
    G4cout << G4endl;
    if(region->IsInMassGeometry())
    {
      G4cout << " This region is in the mass world." << G4endl;
    }
    if(region->IsInParallelGeometry())
    {
      G4cout << " This region is in the parallel world." << G4endl;
    }
 
    G4cout << " Root logical volume(s) : ";
    std::size_t nRootLV = region->GetNumberOfRootVolumes();
    auto lvItr = region->GetRootLogicalVolumeIterator();
    for(std::size_t j = 0; j < nRootLV; ++j)
    {
      G4cout << (*lvItr)->GetName() << " ";
      ++lvItr;
    }
    G4cout << G4endl;
 
    G4cout << " Pointers : G4VUserRegionInformation["
           << region->GetUserInformation() << "], G4UserLimits["
           << region->GetUserLimits() << "], G4FastSimulationManager["
           << region->GetFastSimulationManager() << "], G4UserSteppingAction["
           << region->GetRegionalSteppingAction() << "]" << G4endl;
 
    G4cout << " Materials : ";
    auto mItr = region->GetMaterialIterator();
    std::size_t nMaterial = region->GetNumberOfMaterials();
    for(std::size_t iMate = 0; iMate < nMaterial; ++iMate)
    {
      G4cout << (*mItr)->GetName() << " ";
      ++mItr;
    }
    G4cout << G4endl;
    G4ProductionCuts* cuts = region->GetProductionCuts();
    if(!cuts && region->IsInMassGeometry())
    {
      G4cerr << "Warning : Region <" << region->GetName()
             << "> does not have specific production cuts." << G4endl;
      G4cerr << "Default cuts are used for this region." << G4endl;
      region->SetProductionCuts(G4ProductionCutsTable::GetProductionCutsTable()
                                  ->GetDefaultProductionCuts());
    }
    else if(cuts != nullptr)
    {
      G4cout << " Production cuts : "
             << "  gamma "
             << G4BestUnit(cuts->GetProductionCut("gamma"), "Length")
             << "     e- " << G4BestUnit(cuts->GetProductionCut("e-"), "Length")
             << "     e+ " << G4BestUnit(cuts->GetProductionCut("e+"), "Length")
             << " proton "
             << G4BestUnit(cuts->GetProductionCut("proton"), "Length")
             << G4endl;
    }
  }
}

References DumpRegion(), G4BestUnit, G4cerr, G4cout, G4endl, G4Region::GetFastSimulationManager(), G4RegionStore::GetInstance(), G4Region::GetMaterialIterator(), G4Region::GetName(), G4VPhysicalVolume::GetName(), G4Region::GetNumberOfMaterials(), G4Region::GetNumberOfRootVolumes(), G4ProductionCuts::GetProductionCut(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4Region::GetRegionalSteppingAction(), G4Region::GetRootLogicalVolumeIterator(), G4Region::GetUserInformation(), G4Region::GetUserLimits(), G4Region::GetWorldPhysical(), G4Region::IsInMassGeometry(), G4Region::IsInParallelGeometry(), G4Threading::IsWorkerThread(), and G4Region::SetProductionCuts().

◆ GeometryHasBeenModified()

void G4RunManagerKernel::GeometryHasBeenModified ( )

inline

Definition at line 119 of file G4RunManagerKernel.hh.

119{ geometryNeedsToBeClosed = true; }

References geometryNeedsToBeClosed.

Referenced by G4RunManager::GeometryHasBeenModified(), G4RunManager::ReinitializeGeometry(), and G4RunManager::SetGeometryToBeOptimized().

◆ GetCurrentWorld()

G4VPhysicalVolume * G4RunManagerKernel::GetCurrentWorld ( ) const

inline

Definition at line 169 of file G4RunManagerKernel.hh.

169{ return currentWorld; }

References currentWorld.

Referenced by G4WorkerRunManager::InitializeGeometry().

◆ GetEventManager()

G4EventManager * G4RunManagerKernel::GetEventManager ( ) const

inline

Definition at line 130 of file G4RunManagerKernel.hh.

130{ return eventManager; }

References eventManager.

Referenced by G4RunManager::G4RunManager().

◆ GetNumberOfParallelWorld()

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inline

Definition at line 161 of file G4RunManagerKernel.hh.

    {
      return numberOfParallelWorld;
    }

References numberOfParallelWorld.

Referenced by G4PhysicsListHelper::AddTransportation(), and G4WorkerRunManager::InitializeGeometry().

◆ GetNumberOfStaticAllocators()

G4int G4RunManagerKernel::GetNumberOfStaticAllocators ( ) const

inline

Definition at line 171 of file G4RunManagerKernel.hh.

    {
      return numberOfStaticAllocators;
    }

References numberOfStaticAllocators.

Referenced by G4MTRunManager::G4MTRunManager(), and G4TaskRunManager::G4TaskRunManager().

◆ GetPhysicsList()

G4VUserPhysicsList * G4RunManagerKernel::GetPhysicsList ( ) const

inline

Definition at line 167 of file G4RunManagerKernel.hh.

167{ return physicsList; }

References physicsList.

◆ GetPrimaryTransformer()

G4PrimaryTransformer * G4RunManagerKernel::GetPrimaryTransformer ( ) const

inline

Definition at line 143 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetPrimaryTransformer();
    }

References eventManager, and G4EventManager::GetPrimaryTransformer().

Referenced by RunInitialization().

◆ GetRunManagerKernel()

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

static

Definition at line 98 of file G4RunManagerKernel.cc.

{
  return fRunManagerKernel;
}

References fRunManagerKernel.

Referenced by G4PhysicsListHelper::AddTransportation(), G4VisManager::Disable(), G4MaterialScanner::DoScan(), G4ExceptionHandler::DumpTrackInfo(), export_G4RunManagerKernel(), and G4ErrorRunManagerHelper::G4ErrorRunManagerHelper().

◆ GetStackManager()

G4StackManager * G4RunManagerKernel::GetStackManager ( ) const

inline

Definition at line 131 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetStackManager();
    }

References eventManager, and G4EventManager::GetStackManager().

◆ GetTrackingManager()

G4TrackingManager * G4RunManagerKernel::GetTrackingManager ( ) const

inline

Definition at line 135 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetTrackingManager();
    }

References eventManager, and G4EventManager::GetTrackingManager().

Referenced by G4VisManager::Disable(), and G4ExceptionHandler::DumpTrackInfo().

◆ GetVersionString()

const G4String & G4RunManagerKernel::GetVersionString ( ) const

inline

Definition at line 148 of file G4RunManagerKernel.hh.

148{ return versionString; }

References versionString.

Referenced by G4RunManager::GetVersionString().

◆ InitializePhysics()

void G4RunManagerKernel::InitializePhysics ( )

Definition at line 673 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_Init)
  {
    G4cout << "Current application state is "
           << stateManager->GetStateString(currentState) << G4endl;
    if(!(currentState == G4State_Idle || currentState == G4State_PreInit))
    {
      G4Exception("G4RunManagerKernel::InitializePhysics",
                  "InitializePhysicsIncorrectState", FatalException,
                  "Geant4 kernel is not Init state : Method ignored.");
      return;
    }
    else
    {
      // G4Exception("G4RunManagerKernel::DefineWorldVolume",
      //             "DefineWorldVolumeAtIncorrectState", JustWarning,
      // "Geant4 kernel is not Init state : Assuming Init state.");
      G4cout
        << "Warning : Geant4 kernel is not Init state : Assuming Init state."
        << G4endl;
      stateManager->SetNewState(G4State_Init);
    }
  }
 
  if(physicsList == nullptr)
  {
    G4Exception("G4RunManagerKernel::InitializePhysics", "Run0012",
                FatalException, "G4VUserPhysicsList is not defined");
    return;
  }
 
  if(verboseLevel > 1)
    G4cout << "physicsList->Construct() start." << G4endl;
  if(numberOfParallelWorld > 0)
    physicsList->UseCoupledTransportation();
  physicsList->Construct();
 
  if(verboseLevel > 1)
    G4cout << "physicsList->CheckParticleList() start." << G4endl;
  physicsList->CheckParticleList();
 
  // Cannot assume that SetCuts() and CheckRegions() are thread safe.
  // We need to mutex (report from valgrind --tool=drd)
  G4AutoLock l(&initphysicsmutex);
  if(G4Threading::IsMasterThread())
  {
    if(verboseLevel > 1)
      G4cout << "physicsList->setCut() start." << G4endl;
    physicsList->SetCuts();
  }
  CheckRegions();
  l.unlock();
 
  /*******************
  // static G4bool createIsomerOnlyOnce = false;
  // if(G4Threading::IsMultithreadedApplication() &&
        G4Threading::IsMasterThread())
  // {
  //   if(!createIsomerOnlyOnce)
  //   {
  //     createIsomerOnlyOnce = true;
  //     G4ParticleDefinition* gion =
         G4ParticleTable::GetParticleTable()->GetGenericIon();
  //     if(gion != nullptr)
  //     {
  //       G4ParticleTable::GetParticleTable()
           ->GetIonTable()->CreateAllIsomer();
  //       PropagateGenericIonID();
  //     }
  //   }
  // }
  *********************/
 
  physicsInitialized = true;
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
  stateManager->SetNewState(currentState);
  if(geometryInitialized && currentState != G4State_Idle)
  {
    stateManager->SetNewState(G4State_Idle);
  }
}

References G4VUserPhysicsList::CheckParticleList(), CheckRegions(), G4VUserPhysicsList::Construct(), FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), G4UnitDefinition::GetUnitsTable(), anonymous_namespace{G4RunManagerKernel.cc}::initphysicsmutex, G4Threading::IsMasterThread(), numberOfParallelWorld, physicsInitialized, physicsList, G4VUserPhysicsList::SetCuts(), G4StateManager::SetNewState(), G4TemplateAutoLock< _Mutex_t >::unlock(), G4VUserPhysicsList::UseCoupledTransportation(), and verboseLevel.

Referenced by G4ErrorRunManagerHelper::InitializePhysics(), and G4RunManager::InitializePhysics().

◆ PhysicsHasBeenModified()

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inline

Definition at line 124 of file G4RunManagerKernel.hh.

124{ physicsNeedsToBeReBuilt = true; }

References physicsNeedsToBeReBuilt.

Referenced by G4RunManager::PhysicsHasBeenModified().

◆ PropagateGenericIonID()

void G4RunManagerKernel::PropagateGenericIonID ( )

protected

Definition at line 820 of file G4RunManagerKernel.cc.

{
  G4ParticleDefinition* gion =
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  if(gion != nullptr)
  {
    // G4ParticleTable::GetParticleTable()->GetIonTable()->CreateAllIsomer();
    G4int gionId = gion->GetParticleDefinitionID();
    auto pItr = G4ParticleTable::GetParticleTable()->GetIterator();
    pItr->reset(false);
    while((*pItr)())
    {
      G4ParticleDefinition* particle = pItr->value();
      if(particle->IsGeneralIon())
        particle->SetParticleDefinitionID(gionId);
    }
  }
}

References G4ParticleTable::GetGenericIon(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::IsGeneralIon(), G4ParticleTableIterator< K, V >::reset(), and G4ParticleDefinition::SetParticleDefinitionID().

Referenced by RunInitialization().

◆ ResetNavigator()

void G4RunManagerKernel::ResetNavigator ( )

protected

Definition at line 848 of file G4RunManagerKernel.cc.

{
  if(runManagerKernelType == workerRMK)
  {
    geometryNeedsToBeClosed = false;
    return;
  }
 
  // We have to tweak the navigator's state in case a geometry has been
  // modified between runs. By the following calls we ensure that navigator's
  // state is reset properly. It is required the geometry to be closed
  // and previous optimisations to be cleared.
 
  G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
  if(verboseLevel > 1)
    G4cout << "Start closing geometry." << G4endl;
 
  geomManager->OpenGeometry();
  geomManager->CloseGeometry(geometryToBeOptimized, verboseLevel > 1);
 
  geometryNeedsToBeClosed = false;
}

References G4GeometryManager::CloseGeometry(), G4cout, G4endl, geometryNeedsToBeClosed, geometryToBeOptimized, G4GeometryManager::GetInstance(), G4GeometryManager::OpenGeometry(), runManagerKernelType, verboseLevel, and workerRMK.

Referenced by RunInitialization().

◆ RunInitialization()

G4bool G4RunManagerKernel::RunInitialization ( G4bool fakeRun = false )

Definition at line 761 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
 
  if(!geometryInitialized)
  {
    G4Exception("G4RunManagerKernel::RunInitialization", "Run0021", JustWarning,
                "Geometry has not yet initialized : method ignored.");
    return false;
  }
 
  if(!physicsInitialized)
  {
    G4Exception("G4RunManagerKernel::RunInitialization", "Run0022", JustWarning,
                "Physics has not yet initialized : method ignored.");
    return false;
  }
 
  if(currentState != G4State_Idle)
  {
    G4Exception("G4RunManagerKernel::RunInitialization", "Run0023", JustWarning,
                "Geant4 kernel not in Idle state : method ignored.");
    return false;
  }
 
  if(geometryNeedsToBeClosed)
    CheckRegularGeometry();
 
  stateManager->SetNewState(G4State_Init);
  PropagateGenericIonID();
  SetupShadowProcess();
  UpdateRegion();
  BuildPhysicsTables(fakeRun);
 
  if(geometryNeedsToBeClosed)
  {
    ResetNavigator();
    // CheckRegularGeometry();
    // Notify the VisManager as well
    if(G4Threading::IsMasterThread())
    {
      G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
      if(pVVisManager != nullptr)
        pVVisManager->GeometryHasChanged();
    }
  }
 
  GetPrimaryTransformer()->CheckUnknown();
 
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
  stateManager->SetNewState(G4State_Idle);
  stateManager->SetNewState(G4State_GeomClosed);
  return true;
}

References BuildPhysicsTables(), CheckRegularGeometry(), G4PrimaryTransformer::CheckUnknown(), G4Exception(), G4State_GeomClosed, G4State_Idle, G4State_Init, G4VVisManager::GeometryHasChanged(), geometryInitialized, geometryNeedsToBeClosed, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), GetPrimaryTransformer(), G4StateManager::GetStateManager(), G4UnitDefinition::GetUnitsTable(), G4Threading::IsMasterThread(), JustWarning, physicsInitialized, PropagateGenericIonID(), ResetNavigator(), G4StateManager::SetNewState(), SetupShadowProcess(), and UpdateRegion().

Referenced by export_G4RunManagerKernel(), G4ErrorRunManagerHelper::RunInitialization(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), and G4WorkerTaskRunManager::RunInitialization().

◆ RunTermination()

void G4RunManagerKernel::RunTermination ( )

Definition at line 840 of file G4RunManagerKernel.cc.

{
  if(runManagerKernelType != workerRMK)
    G4ProductionCutsTable::GetProductionCutsTable()->PhysicsTableUpdated();
  G4StateManager::GetStateManager()->SetNewState(G4State_Idle);
}

References G4State_Idle, G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), G4ProductionCutsTable::PhysicsTableUpdated(), runManagerKernelType, G4StateManager::SetNewState(), and workerRMK.

Referenced by G4ErrorRunManagerHelper::RunTermination(), and G4RunManager::RunTermination().

◆ SetGeometryToBeOptimized()

void G4RunManagerKernel::SetGeometryToBeOptimized ( G4bool vl )

inline

Definition at line 152 of file G4RunManagerKernel.hh.

    {
      if(geometryToBeOptimized != vl)
      {
        geometryToBeOptimized   = vl;
        geometryNeedsToBeClosed = true;
      }
    }

References geometryNeedsToBeClosed, and geometryToBeOptimized.

Referenced by G4RunManager::SetGeometryToBeOptimized().

◆ SetNumberOfParallelWorld()

void G4RunManagerKernel::SetNumberOfParallelWorld ( G4int i )

inline

Definition at line 165 of file G4RunManagerKernel.hh.

165{ numberOfParallelWorld = i; }

References numberOfParallelWorld.

Referenced by G4RunManager::InitializeGeometry(), and G4WorkerRunManager::InitializeGeometry().

◆ SetPhysics()

void G4RunManagerKernel::SetPhysics ( G4VUserPhysicsList * uPhys )

Definition at line 596 of file G4RunManagerKernel.cc.

{
  physicsList = uPhys;
 
  if(runManagerKernelType == workerRMK)
    return;
 
  SetupPhysics();
  if(verboseLevel > 2)
    G4ParticleTable::GetParticleTable()->DumpTable();
  if(verboseLevel > 1)
  {
    G4cout << "List of instantiated particles "
              "============================================"
           << G4endl;
    G4int nPtcl = G4ParticleTable::GetParticleTable()->entries();
    for(G4int i = 0; i < nPtcl; ++i)
    {
      G4ParticleDefinition* pd =
        G4ParticleTable::GetParticleTable()->GetParticle(i);
      G4cout << pd->GetParticleName() << " ";
      if(i % 10 == 9)
        G4cout << G4endl;
    }
    G4cout << G4endl;
  }
}

References G4ParticleTable::DumpTable(), G4ParticleTable::entries(), G4cout, G4endl, G4ParticleTable::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), physicsList, runManagerKernelType, SetupPhysics(), verboseLevel, and workerRMK.

Referenced by G4ErrorRunManagerHelper::InitializePhysics(), and G4RunManager::SetUserInitialization().

◆ SetPrimaryTransformer()

void G4RunManagerKernel::SetPrimaryTransformer ( G4PrimaryTransformer * pt )

inline

Definition at line 139 of file G4RunManagerKernel.hh.

    {
      eventManager->SetPrimaryTransformer(pt);
    }

References eventManager, and G4EventManager::SetPrimaryTransformer().

Referenced by G4RunManager::SetPrimaryTransformer().

◆ SetScoreSplitter()

void G4RunManagerKernel::SetScoreSplitter ( )

private

Definition at line 1127 of file G4RunManagerKernel.cc.

{
  G4ScoreSplittingProcess* pSplitter = new G4ScoreSplittingProcess();
  G4ParticleTable* theParticleTable  = G4ParticleTable::GetParticleTable();
  auto theParticleIterator = theParticleTable->GetIterator();
 
  // Ensure that Process is added only once to the particles' process managers
  static G4ThreadLocal G4bool InitSplitter = false;
  if(!InitSplitter)
  {
    InitSplitter = true;
 
    theParticleIterator->reset();
    while((*theParticleIterator)())
    {
      G4ParticleDefinition* particle = theParticleIterator->value();
      G4ProcessManager* pmanager     = particle->GetProcessManager();
      if(pmanager)
      {
        pmanager->AddDiscreteProcess(pSplitter);
      }
    }
 
    if(verboseLevel > 0)
    {
      G4cout
        << "G4RunManagerKernel -- G4ScoreSplittingProcess is appended to all "
           "particles."
        << G4endl;
    }
  }
}

References G4ProcessManager::AddDiscreteProcess(), G4cout, G4endl, G4ThreadLocal, G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), theParticleIterator, and verboseLevel.

Referenced by CheckRegularGeometry().

◆ SetupDefaultRegion()

void G4RunManagerKernel::SetupDefaultRegion ( )

protected

Definition at line 330 of file G4RunManagerKernel.cc.

{
  if(runManagerKernelType == workerRMK)
    return;
 
  // Remove old world logical volume from the default region, if exist
  if(defaultRegion->GetNumberOfRootVolumes())
  {
    if(defaultRegion->GetNumberOfRootVolumes() > size_t(1))
    {
      G4Exception("G4RunManager::SetupDefaultRegion", "Run0005", FatalException,
                  "Default world region should have a unique logical volume.");
    }
    auto lvItr = defaultRegion->GetRootLogicalVolumeIterator();
    defaultRegion->RemoveRootLogicalVolume(*lvItr, false);
    if(verboseLevel > 1)
      G4cout
        << "Obsolete world logical volume is removed from the default region."
        << G4endl;
  }
}

References defaultRegion, FatalException, G4cout, G4endl, G4Exception(), G4Region::GetNumberOfRootVolumes(), G4Region::GetRootLogicalVolumeIterator(), G4Region::RemoveRootLogicalVolume(), runManagerKernelType, verboseLevel, and workerRMK.

Referenced by DefineWorldVolume().

◆ SetupPhysics()

void G4RunManagerKernel::SetupPhysics ( )

protected

Definition at line 625 of file G4RunManagerKernel.cc.

{
  G4ParticleTable::GetParticleTable()->SetReadiness();
 
  physicsList->ConstructParticle();
 
  // For sanity reason
  G4Geantino::GeantinoDefinition();
  G4ParticleDefinition* gion =
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  if(gion != nullptr)
  {
    G4IonConstructor::ConstructParticle();
  }
  G4ParticleTable::GetParticleTable()->GetIonTable()->InitializeLightIons();
 
  auto pItr = G4ParticleTable::GetParticleTable()->GetIterator();
  pItr->reset();
  while((*pItr)())
  {
    G4ParticleDefinition* particle = pItr->value();
    if(!(particle->IsGeneralIon()))
      particle->SetParticleDefinitionID();
  }
 
  if(gion != nullptr)
  {
    G4int gionId = gion->GetParticleDefinitionID();
    pItr->reset(false);
    while((*pItr)())
    {
      G4ParticleDefinition* particle = pItr->value();
      if(particle->IsGeneralIon())
        particle->SetParticleDefinitionID(gionId);
    }
  }
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
}

References G4IonConstructor::ConstructParticle(), G4VUserPhysicsList::ConstructParticle(), G4Geantino::GeantinoDefinition(), G4ParticleTable::GetGenericIon(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleTable::GetParticleTable(), G4UnitDefinition::GetUnitsTable(), G4IonTable::InitializeLightIons(), G4ParticleDefinition::IsGeneralIon(), physicsList, G4ParticleTableIterator< K, V >::reset(), G4ParticleDefinition::SetParticleDefinitionID(), and G4ParticleTable::SetReadiness().

Referenced by SetPhysics().

◆ SetupShadowProcess()

void G4RunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented in G4MTRunManagerKernel, G4WorkerRunManagerKernel, G4TaskRunManagerKernel, and G4WorkerTaskRunManagerKernel.

Definition at line 1161 of file G4RunManagerKernel.cc.

{
  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
  auto theParticleIterator = theParticleTable->GetIterator();
  theParticleIterator->reset();
  // loop on particles and get process manager from there list of processes
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* pd = theParticleIterator->value();
    G4ProcessManager* pm     = pd->GetProcessManager();
    if(pm != nullptr)
    {
      G4ProcessVector& procs = *(pm->GetProcessList());
      for(std::size_t idx = 0; idx < procs.size(); ++idx)
      {
        const G4VProcess* masterP = procs[idx]->GetMasterProcess();
        if(masterP == nullptr)
        {
          // Process does not have an associated shadow master process
          // We are in master mode or sequential
          procs[idx]->SetMasterProcess(const_cast<G4VProcess*>(procs[idx]));
        }
      }
    }
  }
}

References G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ProcessVector::size(), and theParticleIterator.

Referenced by RunInitialization(), G4MTRunManagerKernel::SetupShadowProcess(), and G4TaskRunManagerKernel::SetupShadowProcess().

◆ SetVerboseLevel()

void G4RunManagerKernel::SetVerboseLevel ( G4int vl )

inline

Definition at line 150 of file G4RunManagerKernel.hh.

150{ verboseLevel = vl; }

References verboseLevel.

Referenced by G4ErrorRunManagerHelper::G4ErrorRunManagerHelper(), and G4RunManager::SetVerboseLevel().

◆ UpdateRegion()

void G4RunManagerKernel::UpdateRegion ( )

Definition at line 872 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_Init)
  {
    G4Exception("G4RunManagerKernel::UpdateRegion", "Run0024", JustWarning,
                "Geant4 kernel not in Init state : method ignored.");
    return;
  }
 
  if(runManagerKernelType == workerRMK)
    return;
 
  CheckRegions();
 
  G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);
 
  G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(
    currentWorld);
}

References CheckRegions(), currentWorld, G4Exception(), G4State_Init, G4StateManager::GetCurrentState(), G4RegionStore::GetInstance(), G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), JustWarning, runManagerKernelType, G4ProductionCutsTable::UpdateCoupleTable(), G4RegionStore::UpdateMaterialList(), and workerRMK.

Referenced by G4MaterialScanner::DoScan(), and RunInitialization().

◆ WorkerDefineWorldVolume()

void G4RunManagerKernel::WorkerDefineWorldVolume	(	G4VPhysicalVolume *	worldVol,
		G4bool	topologyIsChanged = `true`
	)

Definition at line 455 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_Init)
  {
    if(!(currentState == G4State_Idle || currentState == G4State_PreInit))
    {
      G4cout << "Current application state is "
             << stateManager->GetStateString(currentState) << G4endl;
      G4Exception("G4RunManagerKernel::DefineWorldVolume",
                  "DefineWorldVolumeAtIncorrectState", FatalException,
                  "Geant4 kernel is not Init state : Method ignored.");
      return;
    }
    else
    {
      stateManager->SetNewState(G4State_Init);
    }
  }
 
  currentWorld             = worldVol;
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
  G4TransportationManager* transM =
    G4TransportationManager::GetTransportationManager();
  G4MTRunManager::masterWorlds_t masterWorlds = masterRM->GetMasterWorlds();
  for(auto itrMW = masterWorlds.cbegin();
           itrMW != masterWorlds.cend(); ++itrMW)
  {
    if((*itrMW).first == 0)
    {
      if((*itrMW).second != currentWorld)
      {
        G4Exception("G4RunManagerKernel::WorkerDefineWorldVolume", "RUN3091",
                    FatalException, "Mass world is inconsistent");
      }
      transM->SetWorldForTracking((*itrMW).second);
    }
    else
    {
      transM->RegisterWorld((*itrMW).second);
    }
  }
 
  if(topologyIsChanged)
    geometryNeedsToBeClosed = true;
 
  // Notify the VisManager as well
  if(G4Threading::IsMasterThread())
  {
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if(pVVisManager != nullptr)
      pVVisManager->GeometryHasChanged();
  }
 
  geometryInitialized = true;
  stateManager->SetNewState(currentState);
  if(physicsInitialized && currentState != G4State_Idle)
  {
    stateManager->SetNewState(G4State_Idle);
  }
}

References currentWorld, FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4VVisManager::GeometryHasChanged(), geometryInitialized, geometryNeedsToBeClosed, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4MTRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterWorlds(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), G4TransportationManager::GetTransportationManager(), G4Threading::IsMasterThread(), physicsInitialized, G4TransportationManager::RegisterWorld(), G4StateManager::SetNewState(), and G4TransportationManager::SetWorldForTracking().

Referenced by G4WorkerRunManager::InitializeGeometry().

◆ WorkerUpdateWorldVolume()

void G4RunManagerKernel::WorkerUpdateWorldVolume ( )

Definition at line 434 of file G4RunManagerKernel.cc.

{
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
  G4TransportationManager* transM =
    G4TransportationManager::GetTransportationManager();
  G4MTRunManager::masterWorlds_t masterWorlds    = masterRM->GetMasterWorlds();
  for(auto itrMW = masterWorlds.cbegin();
           itrMW != masterWorlds.cend(); ++itrMW)
  {
    G4VPhysicalVolume* wv = (*itrMW).second;
    G4VPhysicalVolume* pWorld =
      G4TransportationManager::GetTransportationManager()
      ->IsWorldExisting(wv->GetName());
    if(pWorld == nullptr)
    {
      transM->RegisterWorld(wv);
    }
  }
}

References G4MTRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterWorlds(), G4VPhysicalVolume::GetName(), G4TransportationManager::GetTransportationManager(), G4TransportationManager::IsWorldExisting(), and G4TransportationManager::RegisterWorld().

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

Field Documentation

◆ currentWorld

G4VPhysicalVolume* G4RunManagerKernel::currentWorld = nullptr

private

Definition at line 218 of file G4RunManagerKernel.hh.

Referenced by CheckRegions(), DefineWorldVolume(), GetCurrentWorld(), UpdateRegion(), and WorkerDefineWorldVolume().

◆ defaultExceptionHandler

G4ExceptionHandler* G4RunManagerKernel::defaultExceptionHandler = nullptr

private

Definition at line 227 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel(), and ~G4RunManagerKernel().

◆ defaultRegion

G4Region* G4RunManagerKernel::defaultRegion = nullptr

protected

Definition at line 211 of file G4RunManagerKernel.hh.

Referenced by DefineWorldVolume(), G4RunManagerKernel(), and SetupDefaultRegion().

◆ defaultRegionForParallelWorld

G4Region* G4RunManagerKernel::defaultRegionForParallelWorld = nullptr

protected

Definition at line 212 of file G4RunManagerKernel.hh.

Referenced by CheckRegions(), and G4RunManagerKernel().

◆ eventManager

G4EventManager* G4RunManagerKernel::eventManager = nullptr

private

Definition at line 226 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel(), GetEventManager(), GetPrimaryTransformer(), GetStackManager(), GetTrackingManager(), SetPrimaryTransformer(), and ~G4RunManagerKernel().

◆ fRunManagerKernel

G4ThreadLocal G4RunManagerKernel * G4RunManagerKernel::fRunManagerKernel = nullptr

staticprivate

Definition at line 230 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel(), GetRunManagerKernel(), and ~G4RunManagerKernel().

◆ geometryInitialized

G4bool G4RunManagerKernel::geometryInitialized = false

private

Definition at line 219 of file G4RunManagerKernel.hh.

Referenced by DefineWorldVolume(), InitializePhysics(), RunInitialization(), and WorkerDefineWorldVolume().

◆ geometryNeedsToBeClosed

G4bool G4RunManagerKernel::geometryNeedsToBeClosed = true

protected

Definition at line 213 of file G4RunManagerKernel.hh.

Referenced by DefineWorldVolume(), GeometryHasBeenModified(), ResetNavigator(), RunInitialization(), SetGeometryToBeOptimized(), and WorkerDefineWorldVolume().

◆ geometryToBeOptimized

G4bool G4RunManagerKernel::geometryToBeOptimized = true

private

Definition at line 221 of file G4RunManagerKernel.hh.

Referenced by ResetNavigator(), and SetGeometryToBeOptimized().

◆ numberOfParallelWorld

G4int G4RunManagerKernel::numberOfParallelWorld = 0

private

Definition at line 224 of file G4RunManagerKernel.hh.

Referenced by GetNumberOfParallelWorld(), InitializePhysics(), and SetNumberOfParallelWorld().

◆ numberOfStaticAllocators

G4int G4RunManagerKernel::numberOfStaticAllocators = 0

private

Definition at line 232 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel(), GetNumberOfStaticAllocators(), and ~G4RunManagerKernel().

◆ physicsInitialized

G4bool G4RunManagerKernel::physicsInitialized = false

private

Definition at line 220 of file G4RunManagerKernel.hh.

Referenced by DefineWorldVolume(), InitializePhysics(), RunInitialization(), and WorkerDefineWorldVolume().

◆ physicsList

G4VUserPhysicsList* G4RunManagerKernel::physicsList = nullptr

private

Definition at line 217 of file G4RunManagerKernel.hh.

Referenced by BuildPhysicsTables(), GetPhysicsList(), InitializePhysics(), SetPhysics(), and SetupPhysics().

◆ physicsNeedsToBeReBuilt

G4bool G4RunManagerKernel::physicsNeedsToBeReBuilt = true

private

Definition at line 222 of file G4RunManagerKernel.hh.

Referenced by BuildPhysicsTables(), and PhysicsHasBeenModified().

◆ runManagerKernelType

RMKType G4RunManagerKernel::runManagerKernelType

protected

Definition at line 210 of file G4RunManagerKernel.hh.

Referenced by BuildPhysicsTables(), G4RunManagerKernel(), ResetNavigator(), RunTermination(), SetPhysics(), SetupDefaultRegion(), UpdateRegion(), and ~G4RunManagerKernel().

◆ verboseLevel

G4int G4RunManagerKernel::verboseLevel = 0

private

Definition at line 223 of file G4RunManagerKernel.hh.

Referenced by BuildPhysicsTables(), CheckRegions(), DefineWorldVolume(), G4RunManagerKernel(), InitializePhysics(), ResetNavigator(), SetPhysics(), SetScoreSplitter(), SetupDefaultRegion(), SetVerboseLevel(), and ~G4RunManagerKernel().

◆ versionString

G4String G4RunManagerKernel::versionString = ""

private

Definition at line 228 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel(), and GetVersionString().

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

source/run/include/G4RunManagerKernel.hh
source/run/src/G4RunManagerKernel.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ RMKType

Constructor & Destructor Documentation

◆ G4RunManagerKernel() [1/2]

◆ ~G4RunManagerKernel()

◆ G4RunManagerKernel() [2/2]

Member Function Documentation

◆ BuildPhysicsTables()

◆ CheckRegions()

◆ CheckRegularGeometry()

◆ ConfirmCoupledTransportation()

◆ DefineWorldVolume()

◆ DumpRegion() [1/2]

◆ DumpRegion() [2/2]

◆ GeometryHasBeenModified()

◆ GetCurrentWorld()

◆ GetEventManager()

◆ GetNumberOfParallelWorld()

◆ GetNumberOfStaticAllocators()

◆ GetPhysicsList()

◆ GetPrimaryTransformer()

◆ GetRunManagerKernel()

◆ GetStackManager()

◆ GetTrackingManager()

◆ GetVersionString()

◆ InitializePhysics()

◆ PhysicsHasBeenModified()

◆ PropagateGenericIonID()

◆ ResetNavigator()

◆ RunInitialization()

◆ RunTermination()

◆ SetGeometryToBeOptimized()

◆ SetNumberOfParallelWorld()

◆ SetPhysics()

◆ SetPrimaryTransformer()

◆ SetScoreSplitter()

◆ SetupDefaultRegion()

◆ SetupPhysics()

◆ SetupShadowProcess()

◆ SetVerboseLevel()

◆ UpdateRegion()

◆ WorkerDefineWorldVolume()

◆ WorkerUpdateWorldVolume()

Field Documentation

◆ currentWorld

◆ defaultExceptionHandler

◆ defaultRegion

◆ defaultRegionForParallelWorld

◆ eventManager

◆ fRunManagerKernel

◆ geometryInitialized

◆ geometryNeedsToBeClosed

◆ geometryToBeOptimized

◆ numberOfParallelWorld

◆ numberOfStaticAllocators

◆ physicsInitialized

◆ physicsList

◆ physicsNeedsToBeReBuilt

◆ runManagerKernelType

◆ verboseLevel

◆ versionString