G4RunManagerKernel Class Reference

#include <G4RunManagerKernel.hh>

Inheritance diagram for G4RunManagerKernel:

Public Types
enum	RMKType { sequentialRMK , masterRMK , workerRMK }

Public Member Functions
	G4RunManagerKernel ()
virtual	~G4RunManagerKernel ()
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	WorkerDefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	SetPhysics (G4VUserPhysicsList *uPhys)
void	InitializePhysics ()
G4bool	RunInitialization (G4bool fakeRun=false)
void	RunTermination ()
void	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 67 of file G4RunManagerKernel.hh.

Member Enumeration Documentation

RMKType

enum G4RunManagerKernel::RMKType

Enumerator
sequentialRMK
masterRMK
workerRMK

Definition at line 84 of file G4RunManagerKernel.hh.

  {
    sequentialRMK,
    masterRMK,
    workerRMK
  };

Constructor & Destructor Documentation

G4RunManagerKernel() [1/2]

G4RunManagerKernel::G4RunManagerKernel

(

)

Definition at line 88 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
 
#ifdef G4BT_DEBUG
  auto _signals = G4GetEnv<std::string>("G4BACKTRACE", "");
  if(_signals.empty())
  {
    G4Backtrace::Enable();
  }
  else
  {
    G4Backtrace::Enable(_signals);
  }
#endif
 
  G4AllocatorList* allocList = G4AllocatorList::GetAllocatorListIfExist();
  if(allocList)
    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
         << "                      References : NIM A 506 (2003), 250-303"
         << G4endl
         << "                                 : IEEE-TNS 53 (2006), 270-278"
         << G4endl
         << "                                 : NIM A 835 (2016), 186-225"
         << G4endl << "                             WWW : http://geant4.org/"
         << G4endl
         << "**************************************************************"
         << G4endl << G4endl;
}

~G4RunManagerKernel()

G4RunManagerKernel::~G4RunManagerKernel ( )

virtual

Definition at line 348 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 path-finder field-manager store, geometry and transportation
  // manager
  G4PathFinder* pFinder = G4PathFinder::GetInstanceIfExist();
  if(pFinder)
    delete pFinder;
  G4FieldManagerStore* fmStore = G4FieldManagerStore::GetInstanceIfExist();
  if(fmStore)
    delete fmStore;
  G4GeometryManager* gManager = G4GeometryManager::GetInstanceIfExist();
  if(gManager)
    delete gManager;
  G4TransportationManager* tManager =
    G4TransportationManager::GetInstanceIfExist();
  if(tManager)
  {
    delete tManager;
    if(verboseLevel > 1)
      G4cout << "TransportationManager deleted." << G4endl;
  }
 
  // deletion of navigation levels
  if(verboseLevel > 1)
    G4NavigationHistoryPool::GetInstance()->Print();
  delete G4NavigationHistoryPool::GetInstance();
 
  // deletion of G4RNGHelper singleton
  if(runManagerKernelType != workerRMK)
  {
    G4RNGHelper* rngHelper = G4RNGHelper::GetInstanceIfExist();
    if(rngHelper)
    {
      delete rngHelper;
      if(verboseLevel > 1)
        G4cout << "G4RNGHelper object is deleted." << G4endl;
    }
  }
 
  // 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;
}

G4RunManagerKernel() [2/2]

G4RunManagerKernel::G4RunManagerKernel ( RMKType  rmkType )

protected

Definition at line 186 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
 
#ifdef G4BT_DEBUG
  auto _signals = G4GetEnv<std::string>("G4BACKTRACE", "");
  if(_signals.empty())
  {
    G4Backtrace::Enable();
  }
  else
  {
    G4Backtrace::Enable(_signals);
  }
#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
             << "                      References : NIM A 506 (2003), 250-303"
             << G4endl
             << "                                 : IEEE-TNS 53 (2006), 270-278"
             << G4endl
             << "                                 : NIM A 835 (2016), 186-225"
             << G4endl
             << "                             WWW : http://geant4.org/"
             << G4endl
             << "**************************************************************"
             << G4endl << G4endl;
      break;
    default:
      if(verboseLevel)
      {
        versionString = " Local thread RunManagerKernel version ";
        versionString += vs;
        G4cout
          << G4endl
          << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
             "^^^^^^^^^"
          << G4endl << versionString << G4endl
          << "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"
             "^^^^^^^^^"
          << G4endl << G4endl;
      }
  }
 
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
}

Member Function Documentation

BuildPhysicsTables()

void G4RunManagerKernel::BuildPhysicsTables ( G4bool  fakeRun )

protected

Definition at line 920 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();
    ////G4ProductionCutsTable::GetProductionCutsTable()->PhysicsTableUpdated();
    physicsNeedsToBeReBuilt = false;
  }
 
  if(!fakeRun && verboseLevel > 1)
    DumpRegion();
  if(!fakeRun && verboseLevel > 0)
    physicsList->DumpCutValuesTable();
  if(!fakeRun)
    physicsList->DumpCutValuesTableIfRequested();
}

Referenced by RunInitialization().

CheckRegions()

void G4RunManagerKernel::CheckRegions ( )

protected

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

Referenced by InitializePhysics(), and UpdateRegion().

DefineWorldVolume()

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

Definition at line 542 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
 
  if(currentState != G4State_Init)
  {
    if(!(currentState == G4State_Idle || currentState == G4State_PreInit))
    {
      G4cout << "Current application state is "
             << stateManager->GetStateString(currentState) << G4endl;
      G4Exception("G4RunManagerKernel::DefineWorldVolume",
                  "DefineWorldVolumeAtIncorrectState", FatalException,
                  "Geant4 kernel is not Init state : Method ignored.");
      return;
    }
    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);
  }
}

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

DumpRegion() [1/2]

void G4RunManagerKernel::DumpRegion

(

const G4String &

rname

)

const

Definition at line 1025 of file G4RunManagerKernel.cc.

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

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

DumpRegion() [2/2]

void G4RunManagerKernel::DumpRegion

(

G4Region *

region = 0

)

const

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

GeometryHasBeenModified()

void G4RunManagerKernel::GeometryHasBeenModified ( )

inline

Definition at line 170 of file G4RunManagerKernel.hh.

{ geometryNeedsToBeClosed = true; }

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

GetCurrentWorld()

G4VPhysicalVolume * G4RunManagerKernel::GetCurrentWorld ( ) const

inline

Definition at line 221 of file G4RunManagerKernel.hh.

{ return currentWorld; }

Referenced by G4WorkerRunManager::InitializeGeometry().

GetEventManager()

G4EventManager * G4RunManagerKernel::GetEventManager ( ) const

inline

Definition at line 182 of file G4RunManagerKernel.hh.

{ return eventManager; }

Referenced by G4RunManager::G4RunManager().

GetNumberOfParallelWorld()

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inline

Definition at line 213 of file G4RunManagerKernel.hh.

  {
    return numberOfParallelWorld;
  }

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

GetNumberOfStaticAllocators()

G4int G4RunManagerKernel::GetNumberOfStaticAllocators ( ) const

inline

Definition at line 231 of file G4RunManagerKernel.hh.

  {
    return numberOfStaticAllocators;
  }

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

GetPhysicsList()

G4VUserPhysicsList * G4RunManagerKernel::GetPhysicsList ( ) const

inline

Definition at line 219 of file G4RunManagerKernel.hh.

{ return physicsList; }

GetPrimaryTransformer()

G4PrimaryTransformer * G4RunManagerKernel::GetPrimaryTransformer ( ) const

inline

Definition at line 195 of file G4RunManagerKernel.hh.

  {
    return eventManager->GetPrimaryTransformer();
  }

Referenced by RunInitialization().

GetRunManagerKernel()

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

static

Definition at line 83 of file G4RunManagerKernel.cc.

{
  return fRunManagerKernel;
}

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

GetStackManager()

G4StackManager * G4RunManagerKernel::GetStackManager ( ) const

inline

Definition at line 183 of file G4RunManagerKernel.hh.

  {
    return eventManager->GetStackManager();
  }

GetTrackingManager()

G4TrackingManager * G4RunManagerKernel::GetTrackingManager ( ) const

inline

Definition at line 187 of file G4RunManagerKernel.hh.

  {
    return eventManager->GetTrackingManager();
  }

Referenced by G4VisManager::Disable().

GetVersionString()

const G4String & G4RunManagerKernel::GetVersionString ( ) const

inline

Definition at line 200 of file G4RunManagerKernel.hh.

{ return versionString; }

Referenced by G4RunManager::GetVersionString().

InitializePhysics()

void G4RunManagerKernel::InitializePhysics

(

)

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

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

PhysicsHasBeenModified()

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inline

Definition at line 175 of file G4RunManagerKernel.hh.

{ physicsNeedsToBeReBuilt = true; }

Referenced by G4RunManager::PhysicsHasBeenModified().

PropagateGenericIonID()

void G4RunManagerKernel::PropagateGenericIonID ( )

protected

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

Referenced by RunInitialization().

ResetNavigator()

void G4RunManagerKernel::ResetNavigator ( )

protected

Definition at line 875 of file G4RunManagerKernel.cc.

{
  if(runManagerKernelType == workerRMK)
  {
    geometryNeedsToBeClosed = false;
    return;
  }
 
  // We have to tweak the navigator's state in case a geometry has been
  // modified between runs. By the following calls we ensure that navigator's
  // state is reset properly. It is required the geometry to be closed
  // and previous optimisations to be cleared.
 
  G4GeometryManager* geomManager = G4GeometryManager::GetInstance();
  if(verboseLevel > 1)
    G4cout << "Start closing geometry." << G4endl;
 
  geomManager->OpenGeometry();
  geomManager->CloseGeometry(geometryToBeOptimized, verboseLevel > 1);
 
  geometryNeedsToBeClosed = false;
}

Referenced by RunInitialization().

RunInitialization()

G4bool G4RunManagerKernel::RunInitialization

(

G4bool

fakeRun = false

)

Definition at line 790 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
 
  if(!geometryInitialized)
  {
    G4Exception("G4RunManagerKernel::RunInitialization", "Run0021", JustWarning,
                "Geometry has not yet initialized : method ignored.");
    return false;
  }
 
  if(!physicsInitialized)
  {
    G4Exception("G4RunManagerKernel::RunInitialization", "Run0022", JustWarning,
                "Physics has not yet initialized : method ignored.");
    return false;
  }
 
  if(currentState != G4State_Idle)
  {
    G4Exception("G4RunManagerKernel::RunInitialization", "Run0023", JustWarning,
                "Geant4 kernel not in Idle state : method ignored.");
    return false;
  }
 
  if(geometryNeedsToBeClosed)
    CheckRegularGeometry();
 
  stateManager->SetNewState(G4State_Init);
  PropagateGenericIonID();
  SetupShadowProcess();
  UpdateRegion();
  BuildPhysicsTables(fakeRun);
 
  if(geometryNeedsToBeClosed)
  {
    ResetNavigator();
    // CheckRegularGeometry();
    // Notify the VisManager as well
    if(G4Threading::IsMasterThread())
    {
      G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
      if(pVVisManager)
        pVVisManager->GeometryHasChanged();
    }
  }
 
  GetPrimaryTransformer()->CheckUnknown();
 
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
  stateManager->SetNewState(G4State_Idle);
  stateManager->SetNewState(G4State_GeomClosed);
  return true;
}

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

RunTermination()

void G4RunManagerKernel::RunTermination

(

)

Definition at line 868 of file G4RunManagerKernel.cc.

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

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

SetGeometryToBeOptimized()

void G4RunManagerKernel::SetGeometryToBeOptimized ( G4bool  vl )

inline

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

{ numberOfParallelWorld = i; }

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

SetPhysics()

void G4RunManagerKernel::SetPhysics

(

G4VUserPhysicsList *

uPhys

)

Definition at line 624 of file G4RunManagerKernel.cc.

{
  physicsList = uPhys;
 
  if(runManagerKernelType == workerRMK)
    return;
 
  SetupPhysics();
  if(verboseLevel > 2)
    G4ParticleTable::GetParticleTable()->DumpTable();
  if(verboseLevel > 1)
  {
    G4cout << "List of instantiated particles "
              "============================================"
           << G4endl;
    G4int nPtcl = G4ParticleTable::GetParticleTable()->entries();
    for(G4int i = 0; i < nPtcl; i++)
    {
      G4ParticleDefinition* pd =
        G4ParticleTable::GetParticleTable()->GetParticle(i);
      G4cout << pd->GetParticleName() << " ";
      if(i % 10 == 9)
        G4cout << G4endl;
    }
    G4cout << G4endl;
  }
}

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

SetPrimaryTransformer()

void G4RunManagerKernel::SetPrimaryTransformer ( G4PrimaryTransformer *  pt )

inline

Definition at line 191 of file G4RunManagerKernel.hh.

  {
    eventManager->SetPrimaryTransformer(pt);
  }

Referenced by G4RunManager::SetPrimaryTransformer().

SetupDefaultRegion()

void G4RunManagerKernel::SetupDefaultRegion ( )

protected

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

Referenced by DefineWorldVolume().

SetupPhysics()

void G4RunManagerKernel::SetupPhysics ( )

protected

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

Referenced by SetPhysics().

SetupShadowProcess()

void G4RunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented in G4MTRunManagerKernel, G4WorkerRunManagerKernel, G4TaskRunManagerKernel, and G4WorkerTaskRunManagerKernel.

Definition at line 1194 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(std::size_t 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]));
        }
      }
    }
  }
}

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

SetVerboseLevel()

void G4RunManagerKernel::SetVerboseLevel ( G4int  vl )

inline

Definition at line 202 of file G4RunManagerKernel.hh.

{ verboseLevel = vl; }

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

UpdateRegion()

void G4RunManagerKernel::UpdateRegion

(

)

Definition at line 898 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_Init)
  {
    G4Exception("G4RunManagerKernel::UpdateRegion", "Run0024", JustWarning,
                "Geant4 kernel not in Init state : method ignored.");
    return;
  }
 
  if(runManagerKernelType == workerRMK)
    return;
 
  CheckRegions();
 
  G4RegionStore::GetInstance()->UpdateMaterialList(currentWorld);
 
  G4ProductionCutsTable::GetProductionCutsTable()->UpdateCoupleTable(
    currentWorld);
}

Referenced by RunInitialization().

WorkerDefineWorldVolume()

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

Definition at line 471 of file G4RunManagerKernel.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_Init)
  {
    if(!(currentState == G4State_Idle || currentState == G4State_PreInit))
    {
      G4cout << "Current application state is "
             << stateManager->GetStateString(currentState) << G4endl;
      G4Exception("G4RunManagerKernel::DefineWorldVolume",
                  "DefineWorldVolumeAtIncorrectState", FatalException,
                  "Geant4 kernel is not Init state : Method ignored.");
      return;
    }
    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);
  }
}

Referenced by G4WorkerRunManager::InitializeGeometry().

WorkerUpdateWorldVolume()

void G4RunManagerKernel::WorkerUpdateWorldVolume

(

)

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

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

Member Data Documentation

defaultRegion

G4Region* G4RunManagerKernel::defaultRegion

protected

Definition at line 165 of file G4RunManagerKernel.hh.

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

defaultRegionForParallelWorld

G4Region* G4RunManagerKernel::defaultRegionForParallelWorld

protected

Definition at line 166 of file G4RunManagerKernel.hh.

Referenced by CheckRegions(), and G4RunManagerKernel().

geometryNeedsToBeClosed

G4bool G4RunManagerKernel::geometryNeedsToBeClosed

protected

Definition at line 167 of file G4RunManagerKernel.hh.

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

runManagerKernelType

RMKType G4RunManagerKernel::runManagerKernelType

protected

Definition at line 94 of file G4RunManagerKernel.hh.

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

---

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

• G4RunManagerKernel.hh
• G4RunManagerKernel.cc