G4RunManagerKernel Class Reference

#include <G4RunManagerKernel.hh>

Inheritance diagram for G4RunManagerKernel:

Collaboration 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	WorkerUpdateWorldVolume ()
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)
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
G4Region *	defaultRegionForParallelWorld
G4bool	geometryNeedsToBeClosed

Detailed Description

Definition at line 68 of file G4RunManagerKernel.hh.

Member Enumeration Documentation

enum G4RunManagerKernel::RMKType

Enumerator
sequentialRMK
masterRMK
workerRMK

Definition at line 86 of file G4RunManagerKernel.hh.

{ sequentialRMK, masterRMK, workerRMK };

Constructor & Destructor Documentation

G4RunManagerKernel::G4RunManagerKernel

(

)

Definition at line 78 of file G4RunManagerKernel.cc.

: physicsList(0),currentWorld(0),
 geometryInitialized(false),physicsInitialized(false),
 geometryToBeOptimized(true),
 physicsNeedsToBeReBuilt(true),verboseLevel(0),
 numberOfParallelWorld(0),geometryNeedsToBeClosed(true),
 numberOfStaticAllocators(0)
{
#ifdef G4FPE_DEBUG
  InvalidOperationDetection();
#endif
  G4AllocatorList* allocList = G4AllocatorList::GetAllocatorListIfExist();
  if(allocList) numberOfStaticAllocators = allocList->Size();
  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());

  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
    << "                      Reference : NIM A 506 (2003), 250-303" << G4endl
    << "                            WWW : http://cern.ch/geant4" << G4endl
    << "*************************************************************" << G4endl
    << G4endl;
}

Here is the call graph for this function:

G4RunManagerKernel::~G4RunManagerKernel ( )

virtual

Definition at line 267 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
  G4ParallelWorldProcessStore* pwps = G4ParallelWorldProcessStore::GetInstanceIfExist();
  if(pwps) delete pwps;
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if(fSDM)
  {
    delete fSDM;
    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 navigation levels
  if(verboseLevel>1) G4NavigationHistoryPool::GetInstance()->Print();
  delete G4NavigationHistoryPool::GetInstance();

  // 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;
  }
  if(pUImanager) 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 = 0;
}

Here is the call graph for this function:

G4RunManagerKernel::G4RunManagerKernel ( RMKType  rmkType )

protected

Definition at line 146 of file G4RunManagerKernel.cc.

: physicsList(0),currentWorld(0),
geometryInitialized(false),physicsInitialized(false),
geometryToBeOptimized(true),
physicsNeedsToBeReBuilt(true),verboseLevel(0),
numberOfParallelWorld(0),geometryNeedsToBeClosed(true),
 numberOfStaticAllocators(0)
{
//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
    
    defaultExceptionHandler = new G4ExceptionHandler();
    if(fRunManagerKernel)
    {
        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 = 0;
        defaultRegionForParallelWorld = 0;
        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
       << "                      Reference : NIM A 506 (2003), 250-303" << G4endl
       << "                            WWW : http://cern.ch/geant4" << 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
}

Here is the call graph for this function:

Member Function Documentation

void G4RunManagerKernel::BuildPhysicsTables ( G4bool  fakeRun )

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::CheckRegions ( )

protected

Definition at line 773 of file G4RunManagerKernel.cc.

{
  G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
  size_t nWorlds = transM->GetNoWorlds();
  std::vector<G4VPhysicalVolume*>::iterator wItr;
  for(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(0); // reset
    region->UsedInMassGeometry(false);
    region->UsedInParallelGeometry(false);
    wItr = transM->GetWorldsIterator();
    for(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)
    {
      if(region->IsInMassGeometry())
      {
        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(size_t iw=0;iw<nWorlds;iw++)
  {
    //G4cout << "+++ " << (*wItr)->GetName() << G4endl;
    if(*wItr!=currentWorld)
    {
      G4LogicalVolume* pwLogical = (*wItr)->GetLogicalVolume();
      if(!(pwLogical->GetRegion()))
      {
        pwLogical->SetRegion(defaultRegionForParallelWorld);
        defaultRegionForParallelWorld->AddRootLogicalVolume(pwLogical);
        //G4cout << "+++++ defaultRegionForParallelWorld is set to "
        //       << (*wItr)->GetName() << " +++++" << G4endl;
      }
    }
    wItr++;
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 407 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::DefineWorldVolume",
        "DefineWorldVolumeAtIncorrectState",
        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); 
    }
  }

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

  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) pVVisManager->GeometryHasChanged();
  }

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::DumpRegion

(

const G4String &

rname

)

const

Definition at line 846 of file G4RunManagerKernel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::DumpRegion

(

G4Region *

region = 0

)

const

Definition at line 852 of file G4RunManagerKernel.cc.

{
  if(!region)
  {
    for(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) : ";
    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;
    
    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;
    }
  }
}

Here is the call graph for this function:

void G4RunManagerKernel::GeometryHasBeenModified ( )

inline

Definition at line 164 of file G4RunManagerKernel.hh.

    { geometryNeedsToBeClosed = true; }

Here is the caller graph for this function:

G4VPhysicalVolume* G4RunManagerKernel::GetCurrentWorld ( ) const

inline

Definition at line 212 of file G4RunManagerKernel.hh.

    { return currentWorld; }

Here is the caller graph for this function:

G4EventManager* G4RunManagerKernel::GetEventManager ( ) const

inline

Definition at line 178 of file G4RunManagerKernel.hh.

    { return eventManager; }

Here is the caller graph for this function:

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inline

Definition at line 204 of file G4RunManagerKernel.hh.

    { return numberOfParallelWorld; }

Here is the caller graph for this function:

G4int G4RunManagerKernel::GetNumberOfStaticAllocators ( ) const

inline

Definition at line 222 of file G4RunManagerKernel.hh.

    { return numberOfStaticAllocators; }

Here is the caller graph for this function:

G4VUserPhysicsList* G4RunManagerKernel::GetPhysicsList ( ) const

inline

Definition at line 209 of file G4RunManagerKernel.hh.

    { return physicsList; }

G4PrimaryTransformer* G4RunManagerKernel::GetPrimaryTransformer ( ) const

inline

Definition at line 186 of file G4RunManagerKernel.hh.

    { return eventManager->GetPrimaryTransformer(); }

Here is the call graph for this function:

Here is the caller graph for this function:

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

static

Definition at line 75 of file G4RunManagerKernel.cc.

{ return fRunManagerKernel; }

Here is the caller graph for this function:

G4StackManager* G4RunManagerKernel::GetStackManager ( ) const

inline

Definition at line 180 of file G4RunManagerKernel.hh.

    { return eventManager->GetStackManager(); }

Here is the call graph for this function:

G4TrackingManager* G4RunManagerKernel::GetTrackingManager ( ) const

inline

Definition at line 182 of file G4RunManagerKernel.hh.

    { return eventManager->GetTrackingManager(); }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4String& G4RunManagerKernel::GetVersionString ( ) const

inline

Definition at line 189 of file G4RunManagerKernel.hh.

    { return versionString; }

Here is the caller graph for this function:

void G4RunManagerKernel::InitializePhysics

(

)

Definition at line 548 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)
  {
    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)
//      {
//        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); }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inline

Definition at line 170 of file G4RunManagerKernel.hh.

    { physicsNeedsToBeReBuilt = true; }

Here is the caller graph for this function:

void G4RunManagerKernel::PropagateGenericIonID ( )

protected

Definition at line 685 of file G4RunManagerKernel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::ResetNavigator ( )

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4RunManagerKernel::RunInitialization

(

G4bool

fakeRun = false

)

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

  PropagateGenericIonID();
  SetupShadowProcess();
  UpdateRegion();
  BuildPhysicsTables(fakeRun);

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

#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
  stateManager->SetNewState(G4State_GeomClosed);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::RunTermination

(

)

Definition at line 702 of file G4RunManagerKernel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::SetGeometryToBeOptimized ( G4bool  vl )

inline

Definition at line 195 of file G4RunManagerKernel.hh.

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

Here is the caller graph for this function:

void G4RunManagerKernel::SetNumberOfParallelWorld ( G4int  i )

inline

Definition at line 206 of file G4RunManagerKernel.hh.

    { numberOfParallelWorld = i; }

Here is the caller graph for this function:

void G4RunManagerKernel::SetPhysics

(

G4VUserPhysicsList *

uPhys

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::SetPrimaryTransformer ( G4PrimaryTransformer *  pt )

inline

Definition at line 184 of file G4RunManagerKernel.hh.

    { eventManager->SetPrimaryTransformer(pt); }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::SetupDefaultRegion ( )

protected

Definition at line 244 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.");
        }
        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;
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::SetupPhysics ( )

protected

Definition at line 508 of file G4RunManagerKernel.cc.

{
    G4ParticleTable::GetParticleTable()->SetReadiness();

    physicsList->ConstructParticle();

    // For sanity reason
    G4Geantino::GeantinoDefinition();
    G4ParticleDefinition* gion = G4ParticleTable::GetParticleTable()->GetGenericIon();
    if(gion)
    { G4IonConstructor::ConstructParticle(); }
    G4ParticleTable::GetParticleTable()->GetIonTable()->InitializeLightIons();

    G4ParticleTable::G4PTblDicIterator* pItr = G4ParticleTable::GetParticleTable()->GetIterator();
    pItr->reset();
    while( (*pItr)() )
    {
      G4ParticleDefinition* particle = pItr->value();
      if(!(particle->IsGeneralIon())) particle->SetParticleDefinitionID();
    }

    if(gion)
    {
      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
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented in G4MTRunManagerKernel, and G4WorkerRunManagerKernel.

Definition at line 992 of file G4RunManagerKernel.cc.

{
    G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
    G4ParticleTable::G4PTblDicIterator* 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)
        {
            G4ProcessVector& procs = *(pm->GetProcessList());
            for ( G4int idx = 0 ; idx<procs.size() ; ++idx)
            {
                const G4VProcess* masterP = procs[idx]->GetMasterProcess();
                if ( ! masterP )
                {
                    //Process does not have an associated shadow master process
                    //We are in master mode or sequential
                    procs[idx]->SetMasterProcess(const_cast<G4VProcess*>(procs[idx]));
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::SetVerboseLevel ( G4int  vl )

inline

Definition at line 192 of file G4RunManagerKernel.hh.

    { verboseLevel = vl; }

Here is the caller graph for this function:

void G4RunManagerKernel::UpdateRegion

(

)

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

  if(runManagerKernelType==workerRMK) return;

  CheckRegions();

  G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);

  G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(currentWorld);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 343 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::DefineWorldVolume",
        "DefineWorldVolumeAtIncorrectState",
        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); 
    }
  }

  currentWorld = worldVol;
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
  G4TransportationManager* transM = G4TransportationManager::GetTransportationManager();
  G4MTRunManager::masterWorlds_t masterWorlds= masterRM->GetMasterWorlds();
  G4MTRunManager::masterWorlds_t::iterator itrMW = masterWorlds.begin();
  for(;itrMW!=masterWorlds.end();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) pVVisManager->GeometryHasChanged();
  }

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4RunManagerKernel::WorkerUpdateWorldVolume

(

)

Definition at line 326 of file G4RunManagerKernel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

G4Region* G4RunManagerKernel::defaultRegion

protected

Definition at line 160 of file G4RunManagerKernel.hh.

G4Region* G4RunManagerKernel::defaultRegionForParallelWorld

protected

Definition at line 161 of file G4RunManagerKernel.hh.

G4bool G4RunManagerKernel::geometryNeedsToBeClosed

protected

Definition at line 162 of file G4RunManagerKernel.hh.

RMKType G4RunManagerKernel::runManagerKernelType

protected

Definition at line 90 of file G4RunManagerKernel.hh.

---

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

• geant4.10.03.p01/source/run/include/G4RunManagerKernel.hh
• geant4.10.03.p01/source/run/src/G4RunManagerKernel.cc