G4RunManagerKernel Class Reference

#include <G4RunManagerKernel.hh>

Inheritance diagram for G4RunManagerKernel:

Public Types
enum	RMKType { sequentialRMK , masterRMK , workerRMK }

Public Member Functions
	G4RunManagerKernel ()
virtual	~G4RunManagerKernel ()
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	WorkerDefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	SetPhysics (G4VUserPhysicsList *uPhys)
void	InitializePhysics ()
G4bool	RunInitialization (G4bool fakeRun=false)
void	RunTermination ()
void	UpdateRegion ()
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=nullptr) const
void	WorkerUpdateWorldVolume ()
void	GeometryHasBeenModified ()
void	PhysicsHasBeenModified ()
G4EventManager *	GetEventManager () const
G4StackManager *	GetStackManager () const
G4TrackingManager *	GetTrackingManager () const
void	SetPrimaryTransformer (G4PrimaryTransformer *pt)
G4PrimaryTransformer *	GetPrimaryTransformer () const
const G4String &	GetVersionString () const
void	SetVerboseLevel (G4int vl)
void	SetGeometryToBeOptimized (G4bool vl)
G4int	GetNumberOfParallelWorld () const
void	SetNumberOfParallelWorld (G4int i)
G4VUserPhysicsList *	GetPhysicsList () const
G4VPhysicalVolume *	GetCurrentWorld () const
G4int	GetNumberOfStaticAllocators () const

Static Public Member Functions
static G4RunManagerKernel *	GetRunManagerKernel ()

Protected Member Functions
	G4RunManagerKernel (RMKType rmkType)
void	SetupDefaultRegion ()
void	SetupPhysics ()
void	ResetNavigator ()
void	BuildPhysicsTables (G4bool fakeRun)
void	CheckRegions ()
virtual void	SetupShadowProcess () const
void	PropagateGenericIonID ()

Protected Attributes
RMKType	runManagerKernelType
G4Region *	defaultRegion = nullptr
G4Region *	defaultRegionForParallelWorld = nullptr
G4bool	geometryNeedsToBeClosed = true

Detailed Description

Definition at line 64 of file G4RunManagerKernel.hh.

Member Enumeration Documentation

RMKType

enum G4RunManagerKernel::RMKType

Enumerator
sequentialRMK
masterRMK
workerRMK

Definition at line 163 of file G4RunManagerKernel.hh.

    {
      sequentialRMK,
      masterRMK,
      workerRMK
    };

Constructor & Destructor Documentation

G4RunManagerKernel() [1/2]

G4RunManagerKernel::G4RunManagerKernel

(

)

Definition at line 98 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 = (G4int)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;
}

~G4RunManagerKernel()

G4RunManagerKernel::~G4RunManagerKernel ( )

virtual

Definition at line 301 of file G4RunManagerKernel.cc.

{
  G4StateManager* pStateManager = G4StateManager::GetStateManager();
  // set the application state to the quite state
  if (pStateManager->GetCurrentState() != G4State_Quit) {
    if (verboseLevel > 1) 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 != nullptr) {
    allocList->Destroy(numberOfStaticAllocators, verboseLevel);
    delete allocList;
    if (verboseLevel > 1) G4cout << "G4Allocator objects are deleted." << G4endl;
  }
 
  G4UImanager* pUImanager = G4UImanager::GetUIpointer();
  if ((runManagerKernelType == workerRMK) && (verboseLevel > 1)) {
    G4cout << "Thread-local UImanager is to be deleted." << G4endl
           << "There should not be any thread-local G4cout/G4cerr hereafter." << G4endl;
  }
  delete pUImanager;
  if (verboseLevel > 1) G4cout << "UImanager deleted." << G4endl;
 
  delete pStateManager;
  if (verboseLevel > 1) G4cout << "StateManager deleted." << G4endl;
  delete defaultExceptionHandler;
  if (verboseLevel > 1) G4cout << "RunManagerKernel is deleted. Good bye :)" << G4endl;
  fRunManagerKernel = nullptr;
}

G4RunManagerKernel() [2/2]

G4RunManagerKernel::G4RunManagerKernel ( RMKType rmkType )

protected

Definition at line 173 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 != 0) {
        versionString = " Local thread RunManagerKernel version ";
        versionString += vs;
        G4cout << G4endl
               << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
                  "^^^^^^^^^"
               << G4endl << versionString << G4endl
               << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
                  "^^^^^^^^^"
               << G4endl << G4endl;
      }
  }
 
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
}

Member Function Documentation

BuildPhysicsTables()

void G4RunManagerKernel::BuildPhysicsTables ( G4bool fakeRun )

protected

Definition at line 725 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();
}

Referenced by RunInitialization().

CheckRegions()

void G4RunManagerKernel::CheckRegions ( )

protected

Definition at line 745 of file G4RunManagerKernel.cc.

{
  G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
  std::size_t nWorlds = transM->GetNoWorlds();
  std::vector<G4VPhysicalVolume*>::iterator wItr;
  for (auto region : *G4RegionStore::GetInstance()) {
    // 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;
  }
}

Referenced by InitializePhysics(), and UpdateRegion().

DefineWorldVolume()

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

Definition at line 431 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;
    }
 
    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);
  }
}

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

DumpRegion() [1/2]

void G4RunManagerKernel::DumpRegion

(

const G4String &

rname

)

const

Definition at line 806 of file G4RunManagerKernel.cc.

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

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

DumpRegion() [2/2]

void G4RunManagerKernel::DumpRegion

(

G4Region *

region = nullptr

)

const

Definition at line 813 of file G4RunManagerKernel.cc.

{
  if (region == nullptr) {
    for (const auto& i : *G4RegionStore::GetInstance()) {
      DumpRegion(i);
    }
  }
  else {
    if (G4Threading::IsWorkerThread()) return;
    G4cout << G4endl;
    G4cout << "Region <" << region->GetName() << "> -- ";
    if (region->GetWorldPhysical() != nullptr) {
      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 == nullptr) && 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;
    }
  }
}

GeometryHasBeenModified()

void G4RunManagerKernel::GeometryHasBeenModified ( )

inline

Definition at line 119 of file G4RunManagerKernel.hh.

{ geometryNeedsToBeClosed = true; }

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

GetCurrentWorld()

G4VPhysicalVolume * G4RunManagerKernel::GetCurrentWorld ( ) const

inline

Definition at line 159 of file G4RunManagerKernel.hh.

{ return currentWorld; }

Referenced by G4WorkerRunManager::InitializeGeometry().

GetEventManager()

G4EventManager * G4RunManagerKernel::GetEventManager ( ) const

inline

Definition at line 127 of file G4RunManagerKernel.hh.

{ return eventManager; }

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

GetNumberOfParallelWorld()

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inline

Definition at line 154 of file G4RunManagerKernel.hh.

{ return numberOfParallelWorld; }

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

GetNumberOfStaticAllocators()

G4int G4RunManagerKernel::GetNumberOfStaticAllocators ( ) const

inline

Definition at line 161 of file G4RunManagerKernel.hh.

{ return numberOfStaticAllocators; }

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

GetPhysicsList()

G4VUserPhysicsList * G4RunManagerKernel::GetPhysicsList ( ) const

inline

Definition at line 157 of file G4RunManagerKernel.hh.

{ return physicsList; }

GetPrimaryTransformer()

G4PrimaryTransformer * G4RunManagerKernel::GetPrimaryTransformer ( ) const

inline

Definition at line 137 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetPrimaryTransformer();
    }

Referenced by RunInitialization().

GetRunManagerKernel()

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

static

Definition at line 92 of file G4RunManagerKernel.cc.

{
  return fRunManagerKernel;
}

Referenced by G4PhysicsListHelper::AddTransportation(), G4VisManager::Disable(), and G4ErrorRunManagerHelper::G4ErrorRunManagerHelper().

GetStackManager()

G4StackManager * G4RunManagerKernel::GetStackManager ( ) const

inline

Definition at line 128 of file G4RunManagerKernel.hh.

{ return eventManager->GetStackManager(); }

GetTrackingManager()

G4TrackingManager * G4RunManagerKernel::GetTrackingManager ( ) const

inline

Definition at line 129 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetTrackingManager();
    }

Referenced by G4VisManager::Disable().

GetVersionString()

const G4String & G4RunManagerKernel::GetVersionString ( ) const

inline

Definition at line 142 of file G4RunManagerKernel.hh.

{ return versionString; }

Referenced by G4RunManager::GetVersionString().

InitializePhysics()

void G4RunManagerKernel::InitializePhysics

(

)

Definition at line 554 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;
    }
 
    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();
 
  physicsInitialized = true;
 
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
 
  stateManager->SetNewState(currentState);
  if (geometryInitialized && currentState != G4State_Idle) {
    stateManager->SetNewState(G4State_Idle);
  }
}

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

PhysicsHasBeenModified()

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inline

Definition at line 125 of file G4RunManagerKernel.hh.

{ physicsNeedsToBeReBuilt = true; }

Referenced by G4RunManager::PhysicsHasBeenModified().

PropagateGenericIonID()

void G4RunManagerKernel::PropagateGenericIonID ( )

protected

Definition at line 660 of file G4RunManagerKernel.cc.

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

Referenced by RunInitialization().

ResetNavigator()

void G4RunManagerKernel::ResetNavigator ( )

protected

Definition at line 683 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;
}

Referenced by RunInitialization().

RunInitialization()

G4bool G4RunManagerKernel::RunInitialization

(

G4bool

fakeRun = false

)

Definition at line 607 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;
}

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

RunTermination()

void G4RunManagerKernel::RunTermination

(

)

Definition at line 675 of file G4RunManagerKernel.cc.

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

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

SetGeometryToBeOptimized()

void G4RunManagerKernel::SetGeometryToBeOptimized ( G4bool vl )

inline

Definition at line 146 of file G4RunManagerKernel.hh.

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

Referenced by G4RunManager::SetGeometryToBeOptimized().

SetNumberOfParallelWorld()

void G4RunManagerKernel::SetNumberOfParallelWorld ( G4int i )

inline

Definition at line 155 of file G4RunManagerKernel.hh.

{ numberOfParallelWorld = i; }

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

SetPhysics()

void G4RunManagerKernel::SetPhysics

(

G4VUserPhysicsList *

uPhys

)

Definition at line 490 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;
  }
}

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

SetPrimaryTransformer()

void G4RunManagerKernel::SetPrimaryTransformer ( G4PrimaryTransformer * pt )

inline

Definition at line 133 of file G4RunManagerKernel.hh.

    {
      eventManager->SetPrimaryTransformer(pt);
    }

Referenced by G4RunManager::SetPrimaryTransformer().

SetupDefaultRegion()

void G4RunManagerKernel::SetupDefaultRegion ( )

protected

Definition at line 283 of file G4RunManagerKernel.cc.

{
  if (runManagerKernelType == workerRMK) return;
 
  // Remove old world logical volume from the default region, if exist
  if (defaultRegion->GetNumberOfRootVolumes() != 0u) {
    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;
  }
}

Referenced by DefineWorldVolume().

SetupPhysics()

void G4RunManagerKernel::SetupPhysics ( )

protected

Definition at line 513 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
}

Referenced by SetPhysics().

SetupShadowProcess()

void G4RunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented in G4MTRunManagerKernel, G4TaskRunManagerKernel, G4WorkerRunManagerKernel, and G4WorkerTaskRunManagerKernel.

Definition at line 940 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 (G4int idx = 0; idx < (G4int)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]));
        }
      }
    }
  }
}

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

SetVerboseLevel()

void G4RunManagerKernel::SetVerboseLevel ( G4int vl )

inline

Definition at line 144 of file G4RunManagerKernel.hh.

{ verboseLevel = vl; }

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

UpdateRegion()

void G4RunManagerKernel::UpdateRegion

(

)

Definition at line 705 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);
}

Referenced by RunInitialization().

WorkerDefineWorldVolume()

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

Definition at line 381 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;
    }
 
    stateManager->SetNewState(G4State_Init);
  }
 
  currentWorld = worldVol;
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
  G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
  G4MTRunManager::masterWorlds_t masterWorlds = masterRM->GetMasterWorlds();
  for (const auto& masterWorld : masterWorlds) {
    if (masterWorld.first == 0) {
      if (masterWorld.second != currentWorld) {
        G4Exception("G4RunManagerKernel::WorkerDefineWorldVolume", "RUN3091", FatalException,
                    "Mass world is inconsistent");
      }
      transM->SetWorldForTracking(masterWorld.second);
    }
    else {
      transM->RegisterWorld(masterWorld.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);
  }
}

Referenced by G4WorkerRunManager::InitializeGeometry().

WorkerUpdateWorldVolume()

void G4RunManagerKernel::WorkerUpdateWorldVolume

(

)

Definition at line 365 of file G4RunManagerKernel.cc.

{
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
  G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
  G4MTRunManager::masterWorlds_t masterWorlds = masterRM->GetMasterWorlds();
  for (const auto& masterWorld : masterWorlds) {
    G4VPhysicalVolume* wv = masterWorld.second;
    G4VPhysicalVolume* pWorld =
      G4TransportationManager::GetTransportationManager()->IsWorldExisting(wv->GetName());
    if (pWorld == nullptr) {
      transM->RegisterWorld(wv);
    }
  }
}

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

Member Data Documentation

defaultRegion

G4Region* G4RunManagerKernel::defaultRegion = nullptr

protected

Definition at line 195 of file G4RunManagerKernel.hh.

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

defaultRegionForParallelWorld

G4Region* G4RunManagerKernel::defaultRegionForParallelWorld = nullptr

protected

Definition at line 196 of file G4RunManagerKernel.hh.

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

geometryNeedsToBeClosed

G4bool G4RunManagerKernel::geometryNeedsToBeClosed = true

protected

Definition at line 197 of file G4RunManagerKernel.hh.

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

runManagerKernelType

RMKType G4RunManagerKernel::runManagerKernelType

protected

Definition at line 194 of file G4RunManagerKernel.hh.

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

---

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

• G4RunManagerKernel.hh
• G4RunManagerKernel.cc