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

Private Member Functions
void	CheckRegularGeometry ()
G4bool	ConfirmCoupledTransportation ()
void	SetScoreSplitter ()

Private Attributes
G4VUserPhysicsList *	physicsList
G4VPhysicalVolume *	currentWorld
G4bool	geometryInitialized
G4bool	physicsInitialized
G4bool	geometryToBeOptimized
G4bool	physicsNeedsToBeReBuilt
G4int	verboseLevel
G4int	numberOfParallelWorld
G4EventManager *	eventManager
G4ExceptionHandler *	defaultExceptionHandler
G4String	versionString
G4int	numberOfStaticAllocators

Static Private Attributes
static G4ThreadLocal G4RunManagerKernel *	fRunManagerKernel = 0

Detailed Description

Definition at line 68 of file G4RunManagerKernel.hh.

Member Enumeration Documentation

RMKType

enum G4RunManagerKernel::RMKType

Enumerator
sequentialRMK
masterRMK
workerRMK

Definition at line 86 of file G4RunManagerKernel.hh.

{ sequentialRMK, masterRMK, workerRMK };

Constructor & Destructor Documentation

G4RunManagerKernel() [1/2]

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

virtual

Definition at line 261 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() [2/2]

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)","Run0035",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)","Run0035",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:
      versionString = " Local thread RunManagerKernel version ";
      versionString += vs;
      G4cout << G4endl
       << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << G4endl
       << versionString << G4endl
       << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << G4endl
       << G4endl;
    }
}

Here is the call graph for this function:

Member Function Documentation

BuildPhysicsTables()

void G4RunManagerKernel::BuildPhysicsTables ( G4bool  fakeRun )

protected

Definition at line 694 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:

CheckRegions()

void G4RunManagerKernel::CheckRegions ( )

protected

Definition at line 717 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:

CheckRegularGeometry()

void G4RunManagerKernel::CheckRegularGeometry ( )

private

Definition at line 868 of file G4RunManagerKernel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ConfirmCoupledTransportation()

G4bool G4RunManagerKernel::ConfirmCoupledTransportation ( )

private

Definition at line 889 of file G4RunManagerKernel.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

DefineWorldVolume()

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

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

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

DumpRegion() [1/2]

void G4RunManagerKernel::DumpRegion

(

const G4String &

rname

)

const

Definition at line 790 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:

DumpRegion() [2/2]

void G4RunManagerKernel::DumpRegion

(

G4Region *

region = 0

)

const

Definition at line 796 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:

GeometryHasBeenModified()

void G4RunManagerKernel::GeometryHasBeenModified ( )

inline

Definition at line 164 of file G4RunManagerKernel.hh.

    { geometryNeedsToBeClosed = true; }

Here is the caller graph for this function:

GetCurrentWorld()

G4VPhysicalVolume* G4RunManagerKernel::GetCurrentWorld ( ) const

inline

Definition at line 212 of file G4RunManagerKernel.hh.

    { return currentWorld; }

Here is the call graph for this function:

Here is the caller graph for this function:

GetEventManager()

G4EventManager* G4RunManagerKernel::GetEventManager ( ) const

inline

Definition at line 178 of file G4RunManagerKernel.hh.

    { return eventManager; }

Here is the caller graph for this function:

GetNumberOfParallelWorld()

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inline

Definition at line 204 of file G4RunManagerKernel.hh.

    { return numberOfParallelWorld; }

Here is the caller graph for this function:

GetNumberOfStaticAllocators()

G4int G4RunManagerKernel::GetNumberOfStaticAllocators ( ) const

inline

Definition at line 222 of file G4RunManagerKernel.hh.

    { return numberOfStaticAllocators; }

Here is the call graph for this function:

Here is the caller graph for this function:

GetPhysicsList()

G4VUserPhysicsList* G4RunManagerKernel::GetPhysicsList ( ) const

inline

Definition at line 209 of file G4RunManagerKernel.hh.

    { return physicsList; }

GetPrimaryTransformer()

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:

GetRunManagerKernel()

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

static

Definition at line 75 of file G4RunManagerKernel.cc.

{ return fRunManagerKernel; }

Here is the caller graph for this function:

GetStackManager()

G4StackManager* G4RunManagerKernel::GetStackManager ( ) const

inline

Definition at line 180 of file G4RunManagerKernel.hh.

    { return eventManager->GetStackManager(); }

Here is the call graph for this function:

GetTrackingManager()

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:

GetVersionString()

const G4String& G4RunManagerKernel::GetVersionString ( ) const

inline

Definition at line 189 of file G4RunManagerKernel.hh.

    { return versionString; }

Here is the caller graph for this function:

InitializePhysics()

void G4RunManagerKernel::InitializePhysics

(

)

Definition at line 513 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();
    //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;
  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:

PhysicsHasBeenModified()

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inline

Definition at line 170 of file G4RunManagerKernel.hh.

    { physicsNeedsToBeReBuilt = true; }

Here is the caller graph for this function:

PropagateGenericIonID()

void G4RunManagerKernel::PropagateGenericIonID ( )

protected

Definition at line 629 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:

ResetNavigator()

void G4RunManagerKernel::ResetNavigator ( )

protected

Definition at line 653 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:

RunInitialization()

G4bool G4RunManagerKernel::RunInitialization

(

G4bool

fakeRun = false

)

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

RunTermination()

void G4RunManagerKernel::RunTermination

(

)

Definition at line 646 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:

SetGeometryToBeOptimized()

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:

SetNumberOfParallelWorld()

void G4RunManagerKernel::SetNumberOfParallelWorld ( G4int  i )

inline

Definition at line 206 of file G4RunManagerKernel.hh.

    { numberOfParallelWorld = i; }

Here is the caller graph for this function:

SetPhysics()

void G4RunManagerKernel::SetPhysics

(

G4VUserPhysicsList *

uPhys

)

Definition at line 449 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:

SetPrimaryTransformer()

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:

SetScoreSplitter()

void G4RunManagerKernel::SetScoreSplitter ( )

private

Definition at line 909 of file G4RunManagerKernel.cc.

{
  G4ScoreSplittingProcess* pSplitter = new G4ScoreSplittingProcess();
  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
  G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();

  // Ensure that Process is added only once to the particles' process managers
  static G4ThreadLocal bool InitSplitter=false; 
  if( ! InitSplitter ) {
    InitSplitter = true;

    theParticleIterator->reset();
    while( (*theParticleIterator)() )  
    {
      G4ParticleDefinition* particle = theParticleIterator->value();
      G4ProcessManager* pmanager = particle->GetProcessManager();
      if(pmanager)
    { pmanager->AddDiscreteProcess(pSplitter); }
    }

    if(verboseLevel>0) 
    {
      G4cout << "G4RunManagerKernel -- G4ScoreSplittingProcess is appended to all particles." << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetupDefaultRegion()

void G4RunManagerKernel::SetupDefaultRegion ( )

protected

Definition at line 238 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:

SetupPhysics()

void G4RunManagerKernel::SetupPhysics ( )

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetupShadowProcess()

void G4RunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented in G4MTRunManagerKernel, and G4WorkerRunManagerKernel.

Definition at line 936 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:

SetVerboseLevel()

void G4RunManagerKernel::SetVerboseLevel ( G4int  vl )

inline

Definition at line 192 of file G4RunManagerKernel.hh.

    { verboseLevel = vl; }

Here is the caller graph for this function:

UpdateRegion()

void G4RunManagerKernel::UpdateRegion

(

)

Definition at line 672 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:

WorkerDefineWorldVolume()

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

Definition at line 337 of file G4RunManagerKernel.cc.

{
  G4StateManager*    stateManager = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState==G4State_Idle||currentState==G4State_PreInit))
  {
    G4Exception("G4RunManagerKernel::DefineWorldVolume",
        "DefineWorldVolumeAtIncorrectState",
        JustWarning,
        "Geant4 kernel is not PreInit or Idle state : Method ignored.");
    if(verboseLevel>1) G4cerr << "Current application state is "
      << stateManager->GetStateString(currentState) << G4endl;
    return;
  }

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

WorkerUpdateWorldVolume()

void G4RunManagerKernel::WorkerUpdateWorldVolume

(

)

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

currentWorld

G4VPhysicalVolume* G4RunManagerKernel::currentWorld

private

Definition at line 148 of file G4RunManagerKernel.hh.

defaultExceptionHandler

G4ExceptionHandler* G4RunManagerKernel::defaultExceptionHandler

private

Definition at line 157 of file G4RunManagerKernel.hh.

defaultRegion

G4Region* G4RunManagerKernel::defaultRegion

protected

Definition at line 160 of file G4RunManagerKernel.hh.

defaultRegionForParallelWorld

G4Region* G4RunManagerKernel::defaultRegionForParallelWorld

protected

Definition at line 161 of file G4RunManagerKernel.hh.

eventManager

G4EventManager* G4RunManagerKernel::eventManager

private

Definition at line 156 of file G4RunManagerKernel.hh.

fRunManagerKernel

G4ThreadLocal G4RunManagerKernel * G4RunManagerKernel::fRunManagerKernel = 0

staticprivate

Definition at line 76 of file G4RunManagerKernel.hh.

geometryInitialized

G4bool G4RunManagerKernel::geometryInitialized

private

Definition at line 149 of file G4RunManagerKernel.hh.

geometryNeedsToBeClosed

G4bool G4RunManagerKernel::geometryNeedsToBeClosed

protected

Definition at line 162 of file G4RunManagerKernel.hh.

geometryToBeOptimized

G4bool G4RunManagerKernel::geometryToBeOptimized

private

Definition at line 151 of file G4RunManagerKernel.hh.

numberOfParallelWorld

G4int G4RunManagerKernel::numberOfParallelWorld

private

Definition at line 154 of file G4RunManagerKernel.hh.

numberOfStaticAllocators

G4int G4RunManagerKernel::numberOfStaticAllocators

private

Definition at line 219 of file G4RunManagerKernel.hh.

physicsInitialized

G4bool G4RunManagerKernel::physicsInitialized

private

Definition at line 150 of file G4RunManagerKernel.hh.

physicsList

G4VUserPhysicsList* G4RunManagerKernel::physicsList

private

Definition at line 147 of file G4RunManagerKernel.hh.

physicsNeedsToBeReBuilt

G4bool G4RunManagerKernel::physicsNeedsToBeReBuilt

private

Definition at line 152 of file G4RunManagerKernel.hh.

runManagerKernelType

RMKType G4RunManagerKernel::runManagerKernelType

protected

Definition at line 90 of file G4RunManagerKernel.hh.

verboseLevel

G4int G4RunManagerKernel::verboseLevel

private

Definition at line 153 of file G4RunManagerKernel.hh.

versionString

G4String G4RunManagerKernel::versionString

private

Definition at line 158 of file G4RunManagerKernel.hh.

---

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

• G4RunManagerKernel.hh
• G4RunManagerKernel.cc