G4RunManagerKernel Class Reference

#include <G4RunManagerKernel.hh>

Public Member Functions
	G4RunManagerKernel ()
virtual	~G4RunManagerKernel ()
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	SetPhysics (G4VUserPhysicsList *uPhys)
void	InitializePhysics ()
G4bool	RunInitialization ()
void	RunTermination ()
void	UpdateRegion ()
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=0) const
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)
Static Public Member Functions
static G4RunManagerKernel *	GetRunManagerKernel ()

---

Detailed Description

Definition at line 68 of file G4RunManagerKernel.hh.

---

Constructor & Destructor Documentation

G4RunManagerKernel::G4RunManagerKernel

(

)

Definition at line 65 of file G4RunManagerKernel.cc.

References G4ParticleTable::entries(), FatalException, G4cout, G4endl, G4Exception(), G4State_PreInit, G4ParticleTable::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), G4StateManager::SetNewState(), and G4Region::SetProductionCuts().

:physicsList(0),currentWorld(0),
 geometryInitialized(false),physicsInitialized(false),
 geometryNeedsToBeClosed(true),geometryToBeOptimized(true),
 physicsNeedsToBeReBuilt(true),verboseLevel(0),
 numberOfParallelWorld(0)
{
#ifdef G4FPE_DEBUG
  InvalidOperationDetection();
#endif

  defaultExceptionHandler = new G4ExceptionHandler();
  if(fRunManagerKernel)
  {
    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(int 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());

  // Following line is tentatively moved from SetPhysics method
  // Commented out for introduction of non-static particle definition // G4ParticleTable::GetParticleTable()->SetReadiness();
  // 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
    << "                      Reference : NIM A 506 (2003), 250-303" << G4endl
    << "                            WWW : http://cern.ch/geant4" << G4endl
    << "*************************************************************" << G4endl
    << G4endl;
}

G4RunManagerKernel::~G4RunManagerKernel

(

)

[virtual]

Definition at line 131 of file G4RunManagerKernel.cc.

References G4UnitDefinition::ClearUnitsTable(), G4cout, G4endl, G4State_Quit, G4StateManager::GetCurrentState(), G4GeometryManager::GetInstance(), G4SDManager::GetSDMpointerIfExist(), G4StateManager::GetStateManager(), G4UImanager::GetUIpointer(), G4GeometryManager::OpenGeometry(), and G4StateManager::SetNewState().

{
  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
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if(fSDM)
  {
    delete fSDM;
    if(verboseLevel>1) G4cout << "G4SDManager deleted." << G4endl;
  }
  delete eventManager;
  if(verboseLevel>1) G4cout << "EventManager deleted." << G4endl;
  G4UImanager* pUImanager = G4UImanager::GetUIpointer();
  {
    if(pUImanager) delete pUImanager;
    if(verboseLevel>1) G4cout << "UImanager deleted." << G4endl;
  }
  G4UnitDefinition::ClearUnitsTable();
  if(verboseLevel>1) G4cout << "Units table cleared." << G4endl;
  delete pStateManager; 
  if(verboseLevel>1) G4cout << "StateManager deleted." << G4endl;
  delete defaultExceptionHandler;
  if(verboseLevel>1) G4cout << "RunManagerKernel is deleted." << G4endl;
  fRunManagerKernel = 0;
}

---

Member Function Documentation

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

Definition at line 167 of file G4RunManagerKernel.cc.

References G4Region::AddRootLogicalVolume(), FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_PreInit, G4VVisManager::GeometryHasChanged(), G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4Region::GetName(), G4Region::GetNumberOfRootVolumes(), G4LogicalVolume::GetRegion(), G4Region::GetRootLogicalVolumeIterator(), G4StateManager::GetStateManager(), G4TransportationManager::GetTransportationManager(), JustWarning, G4Region::RemoveRootLogicalVolume(), G4StateManager::SetNewState(), G4LogicalVolume::SetRegion(), and G4TransportationManager::SetWorldForTracking().

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

{
  G4StateManager*    stateManager = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
  { 
    G4Exception("G4RunManagerKernel::DefineWorldVolume",
                "Run00031",
                JustWarning,
                "Geant4 kernel is not PreInit or Idle state : Method ignored.");
    return;
  }

  // The world volume MUST NOT have a region defined by the user
  if(worldVol->GetLogicalVolume()->GetRegion())
  {
    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);
    }
  }

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

  // 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
  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
  if(pVVisManager) pVVisManager->GeometryHasChanged();

  geometryInitialized = true;
  if(physicsInitialized && currentState!=G4State_Idle)
  { stateManager->SetNewState(G4State_Idle); }
} 

void G4RunManagerKernel::DumpRegion

(

G4Region *

region = 0

)

const

Definition at line 494 of file G4RunManagerKernel.cc.

References DumpRegion(), G4BestUnit, G4cerr, G4cout, G4Region::GetFastSimulationManager(), G4RegionStore::GetInstance(), G4Region::GetMaterialIterator(), G4VPhysicalVolume::GetName(), G4Region::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(), and G4Region::SetProductionCuts().

{
  if(!region)
  {
    for(size_t i=0;i<G4RegionStore::GetInstance()->size();i++)
    { DumpRegion((*(G4RegionStore::GetInstance()))[i]); }
  }
  else
  {
    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) : ";
    size_t nRootLV = region->GetNumberOfRootVolumes();
    std::vector<G4LogicalVolume*>::iterator lvItr = region->GetRootLogicalVolumeIterator();
    for(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;
    
//    if(region->GetWorldPhysical()!=currentWorld)
//    {
//      G4cout << G4endl;
//      return;
//    }
    G4cout << " Materials : ";
    std::vector<G4Material*>::const_iterator mItr = region->GetMaterialIterator();
    size_t nMaterial = region->GetNumberOfMaterials();
    for(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)
    {
      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;
    }
  }
}

void G4RunManagerKernel::DumpRegion

(

const G4String &

rname

)

const

Definition at line 488 of file G4RunManagerKernel.cc.

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

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

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

void G4RunManagerKernel::GeometryHasBeenModified

(

)

[inline]

Definition at line 147 of file G4RunManagerKernel.hh.

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

    { geometryNeedsToBeClosed = true; }

G4EventManager* G4RunManagerKernel::GetEventManager

(

)

const [inline]

Definition at line 161 of file G4RunManagerKernel.hh.

Referenced by G4RunManager::G4RunManager().

    { return eventManager; }

G4int G4RunManagerKernel::GetNumberOfParallelWorld

(

)

const [inline]

Definition at line 187 of file G4RunManagerKernel.hh.

Referenced by G4PhysicsListHelper::AddTransportation().

    { return numberOfParallelWorld; }

G4PrimaryTransformer* G4RunManagerKernel::GetPrimaryTransformer

(

)

const [inline]

Definition at line 169 of file G4RunManagerKernel.hh.

References G4EventManager::GetPrimaryTransformer().

Referenced by RunInitialization().

    { return eventManager->GetPrimaryTransformer(); }

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel

(

)

[static]

Definition at line 62 of file G4RunManagerKernel.cc.

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

{ return fRunManagerKernel; }

G4StackManager* G4RunManagerKernel::GetStackManager

(

)

const [inline]

Definition at line 163 of file G4RunManagerKernel.hh.

References G4EventManager::GetStackManager().

    { return eventManager->GetStackManager(); }

G4TrackingManager* G4RunManagerKernel::GetTrackingManager

(

)

const [inline]

Definition at line 165 of file G4RunManagerKernel.hh.

References G4EventManager::GetTrackingManager().

    { return eventManager->GetTrackingManager(); }

const G4String& G4RunManagerKernel::GetVersionString

(

)

const [inline]

Definition at line 172 of file G4RunManagerKernel.hh.

Referenced by G4RunManager::GetVersionString().

    { return versionString; }

void G4RunManagerKernel::InitializePhysics

(

)

Definition at line 258 of file G4RunManagerKernel.cc.

References G4VUserPhysicsList::CheckParticleList(), G4VUserPhysicsList::Construct(), FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, G4VUserPhysicsList::SetCuts(), G4StateManager::SetNewState(), and G4VUserPhysicsList::UseCoupledTransportation().

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

{
  G4StateManager*    stateManager = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
  { 
    G4Exception("G4RunManagerKernel::InitializePhysics",
                "Run0011", JustWarning,
                "Geant4 kernel is not PreInit or Idle state : Method ignored.");
    return;
  }

  if(!physicsList)
  {
    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();
  if(verboseLevel>1) G4cout << "physicsList->setCut() start." << G4endl;
  physicsList->SetCuts();
  CheckRegions();
  physicsInitialized = true;
  if(geometryInitialized && currentState!=G4State_Idle)
  { stateManager->SetNewState(G4State_Idle); }
}

void G4RunManagerKernel::PhysicsHasBeenModified

(

)

[inline]

Definition at line 153 of file G4RunManagerKernel.hh.

Referenced by G4RunManager::PhysicsHasBeenModified().

    { physicsNeedsToBeReBuilt = true; }

G4bool G4RunManagerKernel::RunInitialization

(

)

Definition at line 292 of file G4RunManagerKernel.cc.

References G4PrimaryTransformer::CheckUnknown(), G4Exception(), G4State_GeomClosed, G4State_Idle, G4VVisManager::GeometryHasChanged(), G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), GetPrimaryTransformer(), G4StateManager::GetStateManager(), JustWarning, G4StateManager::SetNewState(), and UpdateRegion().

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

{
  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(numberOfParallelWorld>0)
  //{ // Confirm G4CoupledTransportation is used 
  //  if(!ConfirmCoupledTransportation())
  //  { G4Exception("G4CoupledTransportation must be used for parallel world."); }
  //}
    
  UpdateRegion();
  BuildPhysicsTables();

  if(geometryNeedsToBeClosed)
  {
    ResetNavigator();
    CheckRegularGeometry();
    // Notify the VisManager as well
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if(pVVisManager) pVVisManager->GeometryHasChanged();
  }
 
  GetPrimaryTransformer()->CheckUnknown();

  stateManager->SetNewState(G4State_GeomClosed);
  return true;
}

void G4RunManagerKernel::RunTermination

(

)

Definition at line 348 of file G4RunManagerKernel.cc.

References G4State_Idle, G4StateManager::GetStateManager(), and G4StateManager::SetNewState().

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

{ G4StateManager::GetStateManager()->SetNewState(G4State_Idle); }

void G4RunManagerKernel::SetGeometryToBeOptimized

(

G4bool

vl

)

[inline]

Definition at line 178 of file G4RunManagerKernel.hh.

Referenced by G4RunManager::SetGeometryToBeOptimized().

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

void G4RunManagerKernel::SetNumberOfParallelWorld

(

G4int

i

)

[inline]

Definition at line 189 of file G4RunManagerKernel.hh.

Referenced by G4RunManager::InitializeGeometry().

    { numberOfParallelWorld = i; }

void G4RunManagerKernel::SetPhysics

(

G4VUserPhysicsList *

uPhys

)

Definition at line 238 of file G4RunManagerKernel.cc.

References G4VUserPhysicsList::ConstructParticle(), G4ParticleTable::DumpTable(), G4ParticleTable::entries(), G4cout, G4endl, G4ParticleTable::GetParticleTable(), and G4ParticleTable::SetReadiness().

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

{
  physicsList = uPhys;
  G4ParticleTable::GetParticleTable()->SetReadiness();
  physicsList->ConstructParticle();
  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;
  }
}

void G4RunManagerKernel::SetPrimaryTransformer

(

G4PrimaryTransformer *

pt

)

[inline]

Definition at line 167 of file G4RunManagerKernel.hh.

References G4EventManager::SetPrimaryTransformer().

Referenced by G4RunManager::SetPrimaryTransformer().

    { eventManager->SetPrimaryTransformer(pt); }

void G4RunManagerKernel::SetVerboseLevel

(

G4int

vl

)

[inline]

Definition at line 175 of file G4RunManagerKernel.hh.

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

    { verboseLevel = vl; }

void G4RunManagerKernel::UpdateRegion

(

)

Definition at line 373 of file G4RunManagerKernel.cc.

References G4Exception(), G4State_Idle, G4StateManager::GetCurrentState(), G4RegionStore::GetInstance(), G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), JustWarning, G4ProductionCutsTable::UpdateCoupleTable(), and G4RegionStore::UpdateMaterialList().

Referenced by RunInitialization().

{
  G4StateManager*    stateManager = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if( currentState != G4State_Idle )
  { 
    G4Exception("G4RunManagerKernel::UpdateRegion",
                "Run0024",
                JustWarning,
                "Geant4 kernel not in Idle state : method ignored.");
    return;
  }

  CheckRegions();
  G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);
  G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(currentWorld);
}

---

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

• G4RunManagerKernel.hh
• G4RunManagerKernel.cc

---