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::G4RunManagerKernel

(

)

Definition at line 65 of file G4RunManagerKernel.cc.

: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::~G4RunManagerKernel ( )

virtual

Definition at line 131 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
  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

DefineWorldVolume()

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

Definition at line 167 of file G4RunManagerKernel.cc.

{
  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); }
} 

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

DumpRegion() [1/2]

void G4RunManagerKernel::DumpRegion

(

const G4String &

rname

)

const

Definition at line 488 of file G4RunManagerKernel.cc.

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

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

DumpRegion() [2/2]

void G4RunManagerKernel::DumpRegion

(

G4Region *

region = 0

)

const

Definition at line 494 of file G4RunManagerKernel.cc.

{
  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;
    }
  }
}

GeometryHasBeenModified()

void G4RunManagerKernel::GeometryHasBeenModified ( )

inline

Definition at line 147 of file G4RunManagerKernel.hh.

    { geometryNeedsToBeClosed = true; }

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

GetEventManager()

G4EventManager * G4RunManagerKernel::GetEventManager ( ) const

inline

Definition at line 161 of file G4RunManagerKernel.hh.

    { return eventManager; }

Referenced by G4RunManager::G4RunManager().

GetNumberOfParallelWorld()

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inline

Definition at line 187 of file G4RunManagerKernel.hh.

    { return numberOfParallelWorld; }

Referenced by G4PhysicsListHelper::AddTransportation().

GetPrimaryTransformer()

G4PrimaryTransformer * G4RunManagerKernel::GetPrimaryTransformer ( ) const

inline

Definition at line 169 of file G4RunManagerKernel.hh.

    { return eventManager->GetPrimaryTransformer(); }

Referenced by RunInitialization().

GetRunManagerKernel()

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

static

Definition at line 62 of file G4RunManagerKernel.cc.

{ return fRunManagerKernel; }

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

GetStackManager()

G4StackManager * G4RunManagerKernel::GetStackManager ( ) const

inline

Definition at line 163 of file G4RunManagerKernel.hh.

    { return eventManager->GetStackManager(); }

GetTrackingManager()

G4TrackingManager * G4RunManagerKernel::GetTrackingManager ( ) const

inline

Definition at line 165 of file G4RunManagerKernel.hh.

    { return eventManager->GetTrackingManager(); }

GetVersionString()

const G4String & G4RunManagerKernel::GetVersionString ( ) const

inline

Definition at line 172 of file G4RunManagerKernel.hh.

    { return versionString; }

Referenced by G4RunManager::GetVersionString().

InitializePhysics()

void G4RunManagerKernel::InitializePhysics

(

)

Definition at line 258 of file G4RunManagerKernel.cc.

{
  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); }
}

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

PhysicsHasBeenModified()

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inline

Definition at line 153 of file G4RunManagerKernel.hh.

    { physicsNeedsToBeReBuilt = true; }

Referenced by G4RunManager::PhysicsHasBeenModified().

RunInitialization()

G4bool G4RunManagerKernel::RunInitialization

(

)

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

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

RunTermination()

void G4RunManagerKernel::RunTermination

(

)

Definition at line 348 of file G4RunManagerKernel.cc.

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

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

SetGeometryToBeOptimized()

void G4RunManagerKernel::SetGeometryToBeOptimized ( G4bool  vl )

inline

Definition at line 178 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 189 of file G4RunManagerKernel.hh.

    { numberOfParallelWorld = i; }

Referenced by G4RunManager::InitializeGeometry().

SetPhysics()

void G4RunManagerKernel::SetPhysics

(

G4VUserPhysicsList *

uPhys

)

Definition at line 238 of file G4RunManagerKernel.cc.

{
  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;
  }
}

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

SetPrimaryTransformer()

void G4RunManagerKernel::SetPrimaryTransformer ( G4PrimaryTransformer *  pt )

inline

Definition at line 167 of file G4RunManagerKernel.hh.

    { eventManager->SetPrimaryTransformer(pt); }

Referenced by G4RunManager::SetPrimaryTransformer().

SetVerboseLevel()

void G4RunManagerKernel::SetVerboseLevel ( G4int  vl )

inline

Definition at line 175 of file G4RunManagerKernel.hh.

    { verboseLevel = vl; }

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

UpdateRegion()

void G4RunManagerKernel::UpdateRegion

(

)

Definition at line 373 of file G4RunManagerKernel.cc.

{
  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);
}

Referenced by RunInitialization().

---

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

• G4RunManagerKernel.hh
• G4RunManagerKernel.cc