G4WorkerTaskRunManagerKernel Class Reference

#include <G4WorkerTaskRunManagerKernel.hh>

Inheritance diagram for G4WorkerTaskRunManagerKernel:

Public Types
enum	RMKType { sequentialRMK , masterRMK , workerRMK }

Public Member Functions
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=nullptr) const
	G4WorkerTaskRunManagerKernel ()
void	GeometryHasBeenModified ()
G4VPhysicalVolume *	GetCurrentWorld () const
G4EventManager *	GetEventManager () const
G4int	GetNumberOfParallelWorld () const
G4int	GetNumberOfStaticAllocators () const
G4VUserPhysicsList *	GetPhysicsList () const
G4PrimaryTransformer *	GetPrimaryTransformer () const
G4StackManager *	GetStackManager () const
G4TrackingManager *	GetTrackingManager () const
const G4String &	GetVersionString () const
void	InitializePhysics ()
void	PhysicsHasBeenModified ()
G4bool	RunInitialization (G4bool fakeRun=false)
void	RunTermination ()
void	SetGeometryToBeOptimized (G4bool vl)
void	SetNumberOfParallelWorld (G4int i)
void	SetPhysics (G4VUserPhysicsList *uPhys)
void	SetPrimaryTransformer (G4PrimaryTransformer *pt)
void	SetVerboseLevel (G4int vl)
void	UpdateRegion ()
void	WorkerDefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	WorkerUpdateWorldVolume ()
virtual	~G4WorkerTaskRunManagerKernel ()

Static Public Member Functions
static G4RunManagerKernel *	GetRunManagerKernel ()

Protected Member Functions
void	BuildPhysicsTables (G4bool fakeRun)
void	CheckRegions ()
void	PropagateGenericIonID ()
void	ResetNavigator ()
void	SetupDefaultRegion ()
void	SetupPhysics ()
void	SetupShadowProcess () const

Protected Attributes
G4Region *	defaultRegion = nullptr
G4Region *	defaultRegionForParallelWorld = nullptr
G4bool	geometryNeedsToBeClosed = true
RMKType	runManagerKernelType

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

Private Attributes
G4VPhysicalVolume *	currentWorld = nullptr
G4ExceptionHandler *	defaultExceptionHandler = nullptr
G4EventManager *	eventManager = nullptr
G4bool	geometryInitialized = false
G4bool	geometryToBeOptimized = true
G4int	numberOfParallelWorld = 0
G4int	numberOfStaticAllocators = 0
G4bool	physicsInitialized = false
G4VUserPhysicsList *	physicsList = nullptr
G4bool	physicsNeedsToBeReBuilt = true
G4int	verboseLevel = 0
G4String	versionString = ""

Static Private Attributes
static G4ThreadLocal G4RunManagerKernel *	fRunManagerKernel = nullptr

Detailed Description

Definition at line 59 of file G4WorkerTaskRunManagerKernel.hh.

Member Enumeration Documentation

RMKType

enum G4RunManagerKernel::RMKType

inherited

Enumerator
sequentialRMK
masterRMK
workerRMK

Definition at line 176 of file G4RunManagerKernel.hh.

    {
      sequentialRMK,
      masterRMK,
      workerRMK
    };

Constructor & Destructor Documentation

G4WorkerTaskRunManagerKernel()

G4WorkerTaskRunManagerKernel::G4WorkerTaskRunManagerKernel

(

)

Definition at line 32 of file G4WorkerTaskRunManagerKernel.cc.

  : G4RunManagerKernel(workerRMK)
{
  // 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 RunManager can only be used in mult-threaded "
         "applications.";
  G4Exception("G4RunManagerKernel::G4RunManagerKernel()", "Run0102",
              FatalException, msg);
#endif
}

References FatalException, and G4Exception().

~G4WorkerTaskRunManagerKernel()

G4WorkerTaskRunManagerKernel::~G4WorkerTaskRunManagerKernel ( )

virtual

Definition at line 49 of file G4WorkerTaskRunManagerKernel.cc.

{
  G4ParticleTable::GetParticleTable()->DestroyWorkerG4ParticleTable();
}

References G4ParticleTable::DestroyWorkerG4ParticleTable(), and G4ParticleTable::GetParticleTable().

Member Function Documentation

BuildPhysicsTables()

void G4RunManagerKernel::BuildPhysicsTables ( G4bool  fakeRun )

protectedinherited

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

References G4UImanager::ApplyCommand(), G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::DumpCutValuesTable(), G4VUserPhysicsList::DumpCutValuesTableIfRequested(), G4RunManagerKernel::DumpRegion(), G4ProductionCutsTable::GetProductionCutsTable(), G4UImanager::GetUIpointer(), G4RunManagerKernel::masterRMK, G4RunManagerKernel::physicsList, G4RunManagerKernel::physicsNeedsToBeReBuilt, G4RunManagerKernel::runManagerKernelType, and G4RunManagerKernel::verboseLevel.

Referenced by G4RunManagerKernel::RunInitialization().

CheckRegions()

void G4RunManagerKernel::CheckRegions ( )

protectedinherited

Definition at line 922 of file G4RunManagerKernel.cc.

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

References G4Region::AddRootLogicalVolume(), G4Region::BelongsTo(), G4RunManagerKernel::currentWorld, G4RunManagerKernel::defaultRegionForParallelWorld, G4cout, G4endl, G4ProductionCutsTable::GetDefaultProductionCuts(), G4RegionStore::GetInstance(), G4Region::GetName(), G4TransportationManager::GetNoWorlds(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4LogicalVolume::GetRegion(), G4TransportationManager::GetTransportationManager(), G4TransportationManager::GetWorldsIterator(), G4Region::IsInMassGeometry(), G4Region::IsInParallelGeometry(), G4Region::SetProductionCuts(), G4LogicalVolume::SetRegion(), G4Region::SetWorld(), G4Region::UsedInMassGeometry(), G4Region::UsedInParallelGeometry(), and G4RunManagerKernel::verboseLevel.

Referenced by G4RunManagerKernel::InitializePhysics(), and G4RunManagerKernel::UpdateRegion().

CheckRegularGeometry()

void G4RunManagerKernel::CheckRegularGeometry ( )

privateinherited

Definition at line 1090 of file G4RunManagerKernel.cc.

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

References G4LogicalVolumeStore::GetInstance(), pos, and G4RunManagerKernel::SetScoreSplitter().

Referenced by G4RunManagerKernel::RunInitialization().

ConfirmCoupledTransportation()

G4bool G4RunManagerKernel::ConfirmCoupledTransportation ( )

privateinherited

Definition at line 1107 of file G4RunManagerKernel.cc.

{
  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
  auto 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;
}

References G4ProcessManager::GetAlongStepProcessVector(), G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), theParticleIterator, and typeDoIt.

DefineWorldVolume()

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

inherited

Definition at line 520 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
    {
      stateManager->SetNewState(G4State_Init);
    }
  }
 
  // The world volume MUST NOT have a region defined by the user
  if(worldVol->GetLogicalVolume()->GetRegion() != nullptr)
  {
    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 != nullptr)
      pVVisManager->GeometryHasChanged();
  }
 
  geometryInitialized = true;
  stateManager->SetNewState(currentState);
  if(physicsInitialized && currentState != G4State_Idle)
  {
    stateManager->SetNewState(G4State_Idle);
  }
}

References G4Region::AddRootLogicalVolume(), G4RunManagerKernel::currentWorld, G4RunManagerKernel::defaultRegion, FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4VVisManager::GeometryHasChanged(), G4RunManagerKernel::geometryInitialized, G4RunManagerKernel::geometryNeedsToBeClosed, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4Region::GetName(), G4LogicalVolume::GetRegion(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), G4TransportationManager::GetTransportationManager(), G4Threading::IsMasterThread(), G4RunManagerKernel::physicsInitialized, G4StateManager::SetNewState(), G4LogicalVolume::SetRegion(), G4RunManagerKernel::SetupDefaultRegion(), G4TransportationManager::SetWorldForTracking(), and G4RunManagerKernel::verboseLevel.

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

DumpRegion() [1/2]

void G4RunManagerKernel::DumpRegion ( const G4String &  rname ) const

inherited

Definition at line 999 of file G4RunManagerKernel.cc.

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

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

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

DumpRegion() [2/2]

void G4RunManagerKernel::DumpRegion ( G4Region *  region = nullptr ) const

inherited

Definition at line 1007 of file G4RunManagerKernel.cc.

{
  if(region == nullptr)
  {
    for(std::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) : ";
    std::size_t nRootLV = region->GetNumberOfRootVolumes();
    auto lvItr = region->GetRootLogicalVolumeIterator();
    for(std::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 : ";
    auto mItr = region->GetMaterialIterator();
    std::size_t nMaterial = region->GetNumberOfMaterials();
    for(std::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 != nullptr)
    {
      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;
    }
  }
}

References G4RunManagerKernel::DumpRegion(), G4BestUnit, G4cerr, G4cout, G4endl, G4Region::GetFastSimulationManager(), G4RegionStore::GetInstance(), G4Region::GetMaterialIterator(), G4Region::GetName(), G4VPhysicalVolume::GetName(), G4Region::GetNumberOfMaterials(), G4Region::GetNumberOfRootVolumes(), G4ProductionCuts::GetProductionCut(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4Region::GetRegionalSteppingAction(), G4Region::GetRootLogicalVolumeIterator(), G4Region::GetUserInformation(), G4Region::GetUserLimits(), G4Region::GetWorldPhysical(), G4Region::IsInMassGeometry(), G4Region::IsInParallelGeometry(), G4Threading::IsWorkerThread(), and G4Region::SetProductionCuts().

GeometryHasBeenModified()

void G4RunManagerKernel::GeometryHasBeenModified ( )

inlineinherited

Definition at line 119 of file G4RunManagerKernel.hh.

{ geometryNeedsToBeClosed = true; }

References G4RunManagerKernel::geometryNeedsToBeClosed.

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

GetCurrentWorld()

G4VPhysicalVolume * G4RunManagerKernel::GetCurrentWorld ( ) const

inlineinherited

Definition at line 169 of file G4RunManagerKernel.hh.

{ return currentWorld; }

References G4RunManagerKernel::currentWorld.

Referenced by G4WorkerRunManager::InitializeGeometry().

GetEventManager()

G4EventManager * G4RunManagerKernel::GetEventManager ( ) const

inlineinherited

Definition at line 130 of file G4RunManagerKernel.hh.

{ return eventManager; }

References G4RunManagerKernel::eventManager.

Referenced by G4RunManager::G4RunManager().

GetNumberOfParallelWorld()

G4int G4RunManagerKernel::GetNumberOfParallelWorld ( ) const

inlineinherited

Definition at line 161 of file G4RunManagerKernel.hh.

    {
      return numberOfParallelWorld;
    }

References G4RunManagerKernel::numberOfParallelWorld.

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

GetNumberOfStaticAllocators()

G4int G4RunManagerKernel::GetNumberOfStaticAllocators ( ) const

inlineinherited

Definition at line 171 of file G4RunManagerKernel.hh.

    {
      return numberOfStaticAllocators;
    }

References G4RunManagerKernel::numberOfStaticAllocators.

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

GetPhysicsList()

G4VUserPhysicsList * G4RunManagerKernel::GetPhysicsList ( ) const

inlineinherited

Definition at line 167 of file G4RunManagerKernel.hh.

{ return physicsList; }

References G4RunManagerKernel::physicsList.

GetPrimaryTransformer()

G4PrimaryTransformer * G4RunManagerKernel::GetPrimaryTransformer ( ) const

inlineinherited

Definition at line 143 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetPrimaryTransformer();
    }

References G4RunManagerKernel::eventManager, and G4EventManager::GetPrimaryTransformer().

Referenced by G4RunManagerKernel::RunInitialization().

GetRunManagerKernel()

G4RunManagerKernel * G4RunManagerKernel::GetRunManagerKernel ( )

staticinherited

Definition at line 98 of file G4RunManagerKernel.cc.

{
  return fRunManagerKernel;
}

References G4RunManagerKernel::fRunManagerKernel.

Referenced by G4PhysicsListHelper::AddTransportation(), G4VisManager::Disable(), G4MaterialScanner::DoScan(), G4ExceptionHandler::DumpTrackInfo(), export_G4RunManagerKernel(), and G4ErrorRunManagerHelper::G4ErrorRunManagerHelper().

GetStackManager()

G4StackManager * G4RunManagerKernel::GetStackManager ( ) const

inlineinherited

Definition at line 131 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetStackManager();
    }

References G4RunManagerKernel::eventManager, and G4EventManager::GetStackManager().

GetTrackingManager()

G4TrackingManager * G4RunManagerKernel::GetTrackingManager ( ) const

inlineinherited

Definition at line 135 of file G4RunManagerKernel.hh.

    {
      return eventManager->GetTrackingManager();
    }

References G4RunManagerKernel::eventManager, and G4EventManager::GetTrackingManager().

Referenced by G4VisManager::Disable(), and G4ExceptionHandler::DumpTrackInfo().

GetVersionString()

const G4String & G4RunManagerKernel::GetVersionString ( ) const

inlineinherited

Definition at line 148 of file G4RunManagerKernel.hh.

{ return versionString; }

References G4RunManagerKernel::versionString.

Referenced by G4RunManager::GetVersionString().

InitializePhysics()

void G4RunManagerKernel::InitializePhysics ( )

inherited

Definition at line 673 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 == nullptr)
  {
    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 != nullptr)
  //     {
  //       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);
  }
}

References G4VUserPhysicsList::CheckParticleList(), G4RunManagerKernel::CheckRegions(), G4VUserPhysicsList::Construct(), FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4RunManagerKernel::geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), G4UnitDefinition::GetUnitsTable(), anonymous_namespace{G4RunManagerKernel.cc}::initphysicsmutex, G4Threading::IsMasterThread(), G4RunManagerKernel::numberOfParallelWorld, G4RunManagerKernel::physicsInitialized, G4RunManagerKernel::physicsList, G4VUserPhysicsList::SetCuts(), G4StateManager::SetNewState(), G4TemplateAutoLock< _Mutex_t >::unlock(), G4VUserPhysicsList::UseCoupledTransportation(), and G4RunManagerKernel::verboseLevel.

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

PhysicsHasBeenModified()

void G4RunManagerKernel::PhysicsHasBeenModified ( )

inlineinherited

Definition at line 124 of file G4RunManagerKernel.hh.

{ physicsNeedsToBeReBuilt = true; }

References G4RunManagerKernel::physicsNeedsToBeReBuilt.

Referenced by G4RunManager::PhysicsHasBeenModified().

PropagateGenericIonID()

void G4RunManagerKernel::PropagateGenericIonID ( )

protectedinherited

Definition at line 820 of file G4RunManagerKernel.cc.

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

References G4ParticleTable::GetGenericIon(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::IsGeneralIon(), G4ParticleTableIterator< K, V >::reset(), and G4ParticleDefinition::SetParticleDefinitionID().

Referenced by G4RunManagerKernel::RunInitialization().

ResetNavigator()

void G4RunManagerKernel::ResetNavigator ( )

protectedinherited

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

References G4GeometryManager::CloseGeometry(), G4cout, G4endl, G4RunManagerKernel::geometryNeedsToBeClosed, G4RunManagerKernel::geometryToBeOptimized, G4GeometryManager::GetInstance(), G4GeometryManager::OpenGeometry(), G4RunManagerKernel::runManagerKernelType, G4RunManagerKernel::verboseLevel, and G4RunManagerKernel::workerRMK.

Referenced by G4RunManagerKernel::RunInitialization().

RunInitialization()

G4bool G4RunManagerKernel::RunInitialization ( G4bool  fakeRun = false )

inherited

Definition at line 761 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 != nullptr)
        pVVisManager->GeometryHasChanged();
    }
  }
 
  GetPrimaryTransformer()->CheckUnknown();
 
#ifdef G4MULTITHREADED
  G4UnitDefinition::GetUnitsTable().Synchronize();
#endif
  stateManager->SetNewState(G4State_Idle);
  stateManager->SetNewState(G4State_GeomClosed);
  return true;
}

References G4RunManagerKernel::BuildPhysicsTables(), G4RunManagerKernel::CheckRegularGeometry(), G4PrimaryTransformer::CheckUnknown(), G4Exception(), G4State_GeomClosed, G4State_Idle, G4State_Init, G4VVisManager::GeometryHasChanged(), G4RunManagerKernel::geometryInitialized, G4RunManagerKernel::geometryNeedsToBeClosed, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4RunManagerKernel::GetPrimaryTransformer(), G4StateManager::GetStateManager(), G4UnitDefinition::GetUnitsTable(), G4Threading::IsMasterThread(), JustWarning, G4RunManagerKernel::physicsInitialized, G4RunManagerKernel::PropagateGenericIonID(), G4RunManagerKernel::ResetNavigator(), G4StateManager::SetNewState(), G4RunManagerKernel::SetupShadowProcess(), and G4RunManagerKernel::UpdateRegion().

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

RunTermination()

void G4RunManagerKernel::RunTermination ( )

inherited

Definition at line 840 of file G4RunManagerKernel.cc.

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

References G4State_Idle, G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), G4ProductionCutsTable::PhysicsTableUpdated(), G4RunManagerKernel::runManagerKernelType, G4StateManager::SetNewState(), and G4RunManagerKernel::workerRMK.

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

SetGeometryToBeOptimized()

void G4RunManagerKernel::SetGeometryToBeOptimized ( G4bool  vl )

inlineinherited

Definition at line 152 of file G4RunManagerKernel.hh.

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

References G4RunManagerKernel::geometryNeedsToBeClosed, and G4RunManagerKernel::geometryToBeOptimized.

Referenced by G4RunManager::SetGeometryToBeOptimized().

SetNumberOfParallelWorld()

void G4RunManagerKernel::SetNumberOfParallelWorld ( G4int  i )

inlineinherited

Definition at line 165 of file G4RunManagerKernel.hh.

{ numberOfParallelWorld = i; }

References G4RunManagerKernel::numberOfParallelWorld.

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

SetPhysics()

void G4RunManagerKernel::SetPhysics ( G4VUserPhysicsList *  uPhys )

inherited

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

References G4ParticleTable::DumpTable(), G4ParticleTable::entries(), G4cout, G4endl, G4ParticleTable::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4RunManagerKernel::physicsList, G4RunManagerKernel::runManagerKernelType, G4RunManagerKernel::SetupPhysics(), G4RunManagerKernel::verboseLevel, and G4RunManagerKernel::workerRMK.

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

SetPrimaryTransformer()

void G4RunManagerKernel::SetPrimaryTransformer ( G4PrimaryTransformer *  pt )

inlineinherited

Definition at line 139 of file G4RunManagerKernel.hh.

    {
      eventManager->SetPrimaryTransformer(pt);
    }

References G4RunManagerKernel::eventManager, and G4EventManager::SetPrimaryTransformer().

Referenced by G4RunManager::SetPrimaryTransformer().

SetScoreSplitter()

void G4RunManagerKernel::SetScoreSplitter ( )

privateinherited

Definition at line 1127 of file G4RunManagerKernel.cc.

{
  G4ScoreSplittingProcess* pSplitter = new G4ScoreSplittingProcess();
  G4ParticleTable* theParticleTable  = G4ParticleTable::GetParticleTable();
  auto theParticleIterator = theParticleTable->GetIterator();
 
  // Ensure that Process is added only once to the particles' process managers
  static G4ThreadLocal G4bool 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;
    }
  }
}

References G4ProcessManager::AddDiscreteProcess(), G4cout, G4endl, G4ThreadLocal, G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), theParticleIterator, and G4RunManagerKernel::verboseLevel.

Referenced by G4RunManagerKernel::CheckRegularGeometry().

SetupDefaultRegion()

void G4RunManagerKernel::SetupDefaultRegion ( )

protectedinherited

Definition at line 330 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.");
    }
    auto lvItr = defaultRegion->GetRootLogicalVolumeIterator();
    defaultRegion->RemoveRootLogicalVolume(*lvItr, false);
    if(verboseLevel > 1)
      G4cout
        << "Obsolete world logical volume is removed from the default region."
        << G4endl;
  }
}

References G4RunManagerKernel::defaultRegion, FatalException, G4cout, G4endl, G4Exception(), G4Region::GetNumberOfRootVolumes(), G4Region::GetRootLogicalVolumeIterator(), G4Region::RemoveRootLogicalVolume(), G4RunManagerKernel::runManagerKernelType, G4RunManagerKernel::verboseLevel, and G4RunManagerKernel::workerRMK.

Referenced by G4RunManagerKernel::DefineWorldVolume().

SetupPhysics()

void G4RunManagerKernel::SetupPhysics ( )

protectedinherited

Definition at line 625 of file G4RunManagerKernel.cc.

{
  G4ParticleTable::GetParticleTable()->SetReadiness();
 
  physicsList->ConstructParticle();
 
  // For sanity reason
  G4Geantino::GeantinoDefinition();
  G4ParticleDefinition* gion =
    G4ParticleTable::GetParticleTable()->GetGenericIon();
  if(gion != nullptr)
  {
    G4IonConstructor::ConstructParticle();
  }
  G4ParticleTable::GetParticleTable()->GetIonTable()->InitializeLightIons();
 
  auto pItr = G4ParticleTable::GetParticleTable()->GetIterator();
  pItr->reset();
  while((*pItr)())
  {
    G4ParticleDefinition* particle = pItr->value();
    if(!(particle->IsGeneralIon()))
      particle->SetParticleDefinitionID();
  }
 
  if(gion != nullptr)
  {
    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
}

References G4IonConstructor::ConstructParticle(), G4VUserPhysicsList::ConstructParticle(), G4Geantino::GeantinoDefinition(), G4ParticleTable::GetGenericIon(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleDefinitionID(), G4ParticleTable::GetParticleTable(), G4UnitDefinition::GetUnitsTable(), G4IonTable::InitializeLightIons(), G4ParticleDefinition::IsGeneralIon(), G4RunManagerKernel::physicsList, G4ParticleTableIterator< K, V >::reset(), G4ParticleDefinition::SetParticleDefinitionID(), and G4ParticleTable::SetReadiness().

Referenced by G4RunManagerKernel::SetPhysics().

SetupShadowProcess()

void G4WorkerTaskRunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented from G4RunManagerKernel.

Definition at line 56 of file G4WorkerTaskRunManagerKernel.cc.

{
  // Master thread has created processes and setup a pointer
  // to the master process, get it and copy it in this instance
  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();
    G4ProcessManager* pmM    = pd->GetMasterProcessManager();
    if(!pm || !pmM)
    {
      G4ExceptionDescription msg;
      msg
        << "Process manager or process manager shadow to master are not set.\n";
      msg << "Particle : " << pd->GetParticleName() << " (" << pd
          << "), proc-manager: " << pm;
      msg << " proc-manager-shadow: " << pmM;
      G4Exception("G4WorkerTaskRunManagerKernel::SetupShadowProcess()",
                  "Run0116", FatalException, msg);
      return;
    }
    G4ProcessVector& procs  = *(pm->GetProcessList());
    G4ProcessVector& procsM = *(pmM->GetProcessList());
    if(procs.size() != procsM.size())
    {
      G4cout
        << "G4WorkerTaskRunManagerKernel::SetupShadowProcess() for particle <"
        << pd->GetParticleName() << ">" << G4endl;
      G4cout << " ProcessManager : " << pm << " ProcessManagerShadow : " << pmM
             << G4endl;
 
      for(size_t iv1 = 0; iv1 < procs.size(); iv1++)
        G4cout << "  " << iv1 << " - " << procs[iv1]->GetProcessName()
               << G4endl;
 
      G4cout << "--------------------------------------------------------------"
             << G4endl;
 
      for(size_t iv2 = 0; iv2 < procsM.size(); iv2++)
        G4cout << "  " << iv2 << " - " << procsM[iv2]->GetProcessName()
               << G4endl;
 
      G4cout << "--------------------------------------------------------------"
             << G4endl;
 
      G4ExceptionDescription msg;
      msg
        << " Size of G4ProcessVector is inconsistent between master and worker "
           "threads ";
      msg << " for the particle <" << pd->GetParticleName() << ">. \n";
      msg << " size of G4ProcessVector for worker thread is " << procs.size();
      msg << " while master thread is " << procsM.size() << ".";
      G4Exception("G4WorkerTaskRunManagerKernel::SetupShadowProcess()",
                  "Run0117", FatalException, msg);
    }
    // To each process add the reference to the same
    // process from master. Note that we rely on
    // processes being in the correct order!
    // We could use some checking using process name or type
    for(size_t idx = 0; idx < procs.size(); ++idx)
    {
      procs[idx]->SetMasterProcess(procsM[idx]);
    }
  }
}

References FatalException, G4cout, G4endl, G4Exception(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ProcessVector::size(), and theParticleIterator.

SetVerboseLevel()

void G4RunManagerKernel::SetVerboseLevel ( G4int  vl )

inlineinherited

Definition at line 150 of file G4RunManagerKernel.hh.

{ verboseLevel = vl; }

References G4RunManagerKernel::verboseLevel.

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

UpdateRegion()

void G4RunManagerKernel::UpdateRegion ( )

inherited

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

References G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::currentWorld, G4Exception(), G4State_Init, G4StateManager::GetCurrentState(), G4RegionStore::GetInstance(), G4ProductionCutsTable::GetProductionCutsTable(), G4StateManager::GetStateManager(), JustWarning, G4RunManagerKernel::runManagerKernelType, G4ProductionCutsTable::UpdateCoupleTable(), G4RegionStore::UpdateMaterialList(), and G4RunManagerKernel::workerRMK.

Referenced by G4MaterialScanner::DoScan(), and G4RunManagerKernel::RunInitialization().

WorkerDefineWorldVolume()

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

inherited

Definition at line 455 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
    {
      stateManager->SetNewState(G4State_Init);
    }
  }
 
  currentWorld             = worldVol;
  G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
  G4TransportationManager* transM =
    G4TransportationManager::GetTransportationManager();
  G4MTRunManager::masterWorlds_t masterWorlds = masterRM->GetMasterWorlds();
  for(auto itrMW = masterWorlds.cbegin();
           itrMW != masterWorlds.cend(); ++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 != nullptr)
      pVVisManager->GeometryHasChanged();
  }
 
  geometryInitialized = true;
  stateManager->SetNewState(currentState);
  if(physicsInitialized && currentState != G4State_Idle)
  {
    stateManager->SetNewState(G4State_Idle);
  }
}

References G4RunManagerKernel::currentWorld, FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4VVisManager::GeometryHasChanged(), G4RunManagerKernel::geometryInitialized, G4RunManagerKernel::geometryNeedsToBeClosed, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4MTRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterWorlds(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), G4TransportationManager::GetTransportationManager(), G4Threading::IsMasterThread(), G4RunManagerKernel::physicsInitialized, G4TransportationManager::RegisterWorld(), G4StateManager::SetNewState(), and G4TransportationManager::SetWorldForTracking().

Referenced by G4WorkerRunManager::InitializeGeometry().

WorkerUpdateWorldVolume()

void G4RunManagerKernel::WorkerUpdateWorldVolume ( )

inherited

Definition at line 434 of file G4RunManagerKernel.cc.

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

References G4MTRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterWorlds(), G4VPhysicalVolume::GetName(), G4TransportationManager::GetTransportationManager(), G4TransportationManager::IsWorldExisting(), and G4TransportationManager::RegisterWorld().

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

Field Documentation

currentWorld

G4VPhysicalVolume* G4RunManagerKernel::currentWorld = nullptr

privateinherited

Definition at line 218 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DefineWorldVolume(), G4RunManagerKernel::GetCurrentWorld(), G4RunManagerKernel::UpdateRegion(), and G4RunManagerKernel::WorkerDefineWorldVolume().

defaultExceptionHandler

G4ExceptionHandler* G4RunManagerKernel::defaultExceptionHandler = nullptr

privateinherited

Definition at line 227 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::G4RunManagerKernel(), and G4RunManagerKernel::~G4RunManagerKernel().

defaultRegion

G4Region* G4RunManagerKernel::defaultRegion = nullptr

protectedinherited

Definition at line 211 of file G4RunManagerKernel.hh.

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

defaultRegionForParallelWorld

G4Region* G4RunManagerKernel::defaultRegionForParallelWorld = nullptr

protectedinherited

Definition at line 212 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::CheckRegions(), and G4RunManagerKernel::G4RunManagerKernel().

eventManager

G4EventManager* G4RunManagerKernel::eventManager = nullptr

privateinherited

Definition at line 226 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::G4RunManagerKernel(), G4RunManagerKernel::GetEventManager(), G4RunManagerKernel::GetPrimaryTransformer(), G4RunManagerKernel::GetStackManager(), G4RunManagerKernel::GetTrackingManager(), G4RunManagerKernel::SetPrimaryTransformer(), and G4RunManagerKernel::~G4RunManagerKernel().

fRunManagerKernel

G4ThreadLocal G4RunManagerKernel * G4RunManagerKernel::fRunManagerKernel = nullptr

staticprivateinherited

Definition at line 230 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::G4RunManagerKernel(), G4RunManagerKernel::GetRunManagerKernel(), and G4RunManagerKernel::~G4RunManagerKernel().

geometryInitialized

G4bool G4RunManagerKernel::geometryInitialized = false

privateinherited

Definition at line 219 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::DefineWorldVolume(), G4RunManagerKernel::InitializePhysics(), G4RunManagerKernel::RunInitialization(), and G4RunManagerKernel::WorkerDefineWorldVolume().

geometryNeedsToBeClosed

G4bool G4RunManagerKernel::geometryNeedsToBeClosed = true

protectedinherited

Definition at line 213 of file G4RunManagerKernel.hh.

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

geometryToBeOptimized

G4bool G4RunManagerKernel::geometryToBeOptimized = true

privateinherited

Definition at line 221 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::ResetNavigator(), and G4RunManagerKernel::SetGeometryToBeOptimized().

numberOfParallelWorld

G4int G4RunManagerKernel::numberOfParallelWorld = 0

privateinherited

Definition at line 224 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::GetNumberOfParallelWorld(), G4RunManagerKernel::InitializePhysics(), and G4RunManagerKernel::SetNumberOfParallelWorld().

numberOfStaticAllocators

G4int G4RunManagerKernel::numberOfStaticAllocators = 0

privateinherited

Definition at line 232 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::G4RunManagerKernel(), G4RunManagerKernel::GetNumberOfStaticAllocators(), and G4RunManagerKernel::~G4RunManagerKernel().

physicsInitialized

G4bool G4RunManagerKernel::physicsInitialized = false

privateinherited

Definition at line 220 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::DefineWorldVolume(), G4RunManagerKernel::InitializePhysics(), G4RunManagerKernel::RunInitialization(), and G4RunManagerKernel::WorkerDefineWorldVolume().

physicsList

G4VUserPhysicsList* G4RunManagerKernel::physicsList = nullptr

privateinherited

Definition at line 217 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::BuildPhysicsTables(), G4RunManagerKernel::GetPhysicsList(), G4RunManagerKernel::InitializePhysics(), G4RunManagerKernel::SetPhysics(), and G4RunManagerKernel::SetupPhysics().

physicsNeedsToBeReBuilt

G4bool G4RunManagerKernel::physicsNeedsToBeReBuilt = true

privateinherited

Definition at line 222 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::BuildPhysicsTables(), and G4RunManagerKernel::PhysicsHasBeenModified().

runManagerKernelType

RMKType G4RunManagerKernel::runManagerKernelType

protectedinherited

Definition at line 210 of file G4RunManagerKernel.hh.

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

verboseLevel

G4int G4RunManagerKernel::verboseLevel = 0

privateinherited

Definition at line 223 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::BuildPhysicsTables(), G4RunManagerKernel::CheckRegions(), G4RunManagerKernel::DefineWorldVolume(), G4RunManagerKernel::G4RunManagerKernel(), G4RunManagerKernel::InitializePhysics(), G4RunManagerKernel::ResetNavigator(), G4RunManagerKernel::SetPhysics(), G4RunManagerKernel::SetScoreSplitter(), G4RunManagerKernel::SetupDefaultRegion(), G4RunManagerKernel::SetVerboseLevel(), and G4RunManagerKernel::~G4RunManagerKernel().

versionString

G4String G4RunManagerKernel::versionString = ""

privateinherited

Definition at line 228 of file G4RunManagerKernel.hh.

Referenced by G4RunManagerKernel::G4RunManagerKernel(), and G4RunManagerKernel::GetVersionString().

---

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

• source/tasking/include/G4WorkerTaskRunManagerKernel.hh
• source/tasking/src/G4WorkerTaskRunManagerKernel.cc