G4TaskRunManagerKernel Class Reference

#include <G4TaskRunManagerKernel.hh>

Inheritance diagram for G4TaskRunManagerKernel:

Public Types
enum	RMKType { sequentialRMK , masterRMK , workerRMK }

Public Member Functions
void	BroadcastAbortRun (G4bool softAbort)
void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=nullptr) const
	G4TaskRunManagerKernel ()
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	SetUpDecayChannels ()
void	SetVerboseLevel (G4int vl)
void	UpdateRegion ()
void	WorkerDefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
void	WorkerUpdateWorldVolume ()
virtual	~G4TaskRunManagerKernel ()

Static Public Member Functions
static void	ExecuteWorkerInit ()
static void	ExecuteWorkerTask ()
static G4RunManagerKernel *	GetRunManagerKernel ()
static G4WorkerThread *	GetWorkerThread ()
static std::vector< G4String > &	InitCommandStack ()
static void	InitializeWorker ()
static void	TerminateWorker ()
static void	TerminateWorker (G4WorkerTaskRunManager *)
static void	TerminateWorkerRunEventLoop ()
static void	TerminateWorkerRunEventLoop (G4WorkerTaskRunManager *)

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

Static Protected Attributes
static G4TASK_DLL std::vector< G4String >	initCmdStack = {}

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 65 of file G4TaskRunManagerKernel.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

G4TaskRunManagerKernel()

G4TaskRunManagerKernel::G4TaskRunManagerKernel

(

)

Definition at line 70 of file G4TaskRunManagerKernel.cc.

  : G4RunManagerKernel(masterRMK)
{
  // 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()", "Run0109",
              FatalException, msg);
#endif
  // Set flag that a MT-type kernel has been instantiated
  G4Threading::SetMultithreadedApplication(true);
}

References FatalException, G4Exception(), and G4Threading::SetMultithreadedApplication().

~G4TaskRunManagerKernel()

G4TaskRunManagerKernel::~G4TaskRunManagerKernel ( )

virtual

Definition at line 90 of file G4TaskRunManagerKernel.cc.

{}

Member Function Documentation

BroadcastAbortRun()

void G4TaskRunManagerKernel::BroadcastAbortRun

(

G4bool

softAbort

)

Definition at line 357 of file G4TaskRunManagerKernel.cc.

{
  G4ConsumeParameters(softAbort);
}

References G4ConsumeParameters().

Referenced by G4TaskRunManager::AbortRun().

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().

ExecuteWorkerInit()

void G4TaskRunManagerKernel::ExecuteWorkerInit ( )

static

Definition at line 233 of file G4TaskRunManagerKernel.cc.

{
  // because of TBB
  if(G4MTRunManager::GetMasterThreadId() == G4ThisThread::get_id())
  {
    G4TaskManager* taskManager =
      G4TaskRunManager::GetMasterRunManager()->GetTaskManager();
    auto _fut = taskManager->async(ExecuteWorkerInit);
    return _fut->get();
  }
 
  // this check is for TBB as there is not a way to run an initialization
  // routine on each thread
  if(!workerRM())
    InitializeWorker();
 
  auto& wrm = workerRM();
  assert(wrm.get() != nullptr);
  wrm->DoCleanup();
}

References PTL::TaskManager::async(), ExecuteWorkerInit(), G4TaskRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterThreadId(), PTL::TaskRunManager::GetTaskManager(), InitializeWorker(), and anonymous_namespace{G4TaskRunManagerKernel.cc}::workerRM().

Referenced by G4TaskRunManager::CreateAndStartWorkers(), and ExecuteWorkerInit().

ExecuteWorkerTask()

void G4TaskRunManagerKernel::ExecuteWorkerTask ( )

static

Definition at line 256 of file G4TaskRunManagerKernel.cc.

{
  // because of TBB
  if(G4MTRunManager::GetMasterThreadId() == G4ThisThread::get_id())
  {
    G4TaskManager* taskManager =
      G4TaskRunManager::GetMasterRunManager()->GetTaskManager();
    auto _fut = taskManager->async(ExecuteWorkerTask);
    return _fut->get();
  }
 
  // this check is for TBB as there is not a way to run an initialization
  // routine on each thread
  if(!workerRM())
    InitializeWorker();
 
  auto& wrm = workerRM();
  assert(wrm.get() != nullptr);
  wrm->DoWork();
}

References PTL::TaskManager::async(), ExecuteWorkerTask(), G4TaskRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterThreadId(), PTL::TaskRunManager::GetTaskManager(), InitializeWorker(), and anonymous_namespace{G4TaskRunManagerKernel.cc}::workerRM().

Referenced by G4TaskRunManager::AddEventTask(), and ExecuteWorkerTask().

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().

GetWorkerThread()

G4WorkerThread * G4TaskRunManagerKernel::GetWorkerThread ( )

static

Definition at line 124 of file G4TaskRunManagerKernel.cc.

{
  return context().get();
}

References anonymous_namespace{G4TaskRunManagerKernel.cc}::context().

InitCommandStack()

std::vector< G4String > & G4TaskRunManagerKernel::InitCommandStack ( )

static

Definition at line 329 of file G4TaskRunManagerKernel.cc.

{
  return initCmdStack;
}

References initCmdStack.

Referenced by G4TaskRunManager::CreateAndStartWorkers().

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().

InitializeWorker()

void G4TaskRunManagerKernel::InitializeWorker ( )

static

!!!!!!!!!!!!!!!!!!!!!!!!! !!!!! IMPORTANT !!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!

!!!!!!!!!!!!!!!!!!!!!!!!!

Definition at line 131 of file G4TaskRunManagerKernel.cc.

{
  if(context() && workerRM())
    return;
 
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  if(G4MTRunManager::GetMasterThreadId() == G4ThisThread::get_id())
  {
    G4TaskManager* taskManager = mrm->GetTaskManager();
    auto _fut                  = taskManager->async(InitializeWorker);
    _fut->wait();
    return;
  }
 
  // Here is not sequential anymore and G4UserWorkerThreadInitialization is
  // a shared user initialization class
  // This means this method cannot use data memebers of G4RunManagerKernel
  // unless they are invariant ("read-only") and can be safely shared.
  //  All the rest that is not invariant should be incapsualted into
  //  the context (or, as for wThreadContext be G4ThreadLocal)
 
  G4Threading::WorkerThreadJoinsPool();
  context().reset(new G4WorkerThread);
 
  //============================
  // Step-0: Thread ID
  //============================
  // Initliazie per-thread stream-output
  // The following line is needed before we actually do IO initialization
  // becasue the constructor of UI manager resets the IO destination.
  context()->SetNumberThreads(mrm->GetThreadPool()->size());
  context()->SetThreadId(G4ThreadPool::get_this_thread_id() - 1);
  G4int thisID = context()->GetThreadId();
  G4Threading::G4SetThreadId(thisID);
  G4UImanager::GetUIpointer()->SetUpForAThread(thisID);
 
  //============================
  // Optimization: optional
  //============================
  // Enforce thread affinity if requested
  context()->SetPinAffinity(mrm->GetPinAffinity());
 
  //============================
  // Step-1: Random number engine
  //============================
  // RNG Engine needs to be initialized by "cloning" the master one.
  const CLHEP::HepRandomEngine* masterEngine = mrm->getMasterRandomEngine();
  mrm->GetUserWorkerThreadInitialization()->SetupRNGEngine(masterEngine);
 
  //============================
  // Step-2: Initialize worker thread
  //============================
  if(mrm->GetUserWorkerInitialization())
    mrm->GetUserWorkerInitialization()->WorkerInitialize();
 
  if(mrm->GetUserActionInitialization())
  {
    G4VSteppingVerbose* sv =
      mrm->GetUserActionInitialization()->InitializeSteppingVerbose();
    if(sv)
      G4VSteppingVerbose::SetInstance(sv);
  }
  // Now initialize worker part of shared objects (geometry/physics)
  context()->BuildGeometryAndPhysicsVector();
  workerRM().reset(static_cast<G4WorkerTaskRunManager*>(
    mrm->GetUserWorkerThreadInitialization()->CreateWorkerRunManager()));
  auto& wrm = workerRM();
  wrm->SetWorkerThread(context().get());
 
  //================================
  // Step-3: Setup worker run manager
  //================================
  // Set the detector and physics list to the worker thread. Share with master
  const G4VUserDetectorConstruction* detector =
    mrm->GetUserDetectorConstruction();
  wrm->G4RunManager::SetUserInitialization(
    const_cast<G4VUserDetectorConstruction*>(detector));
  const G4VUserPhysicsList* physicslist = mrm->GetUserPhysicsList();
  wrm->SetUserInitialization(const_cast<G4VUserPhysicsList*>(physicslist));
 
  //================================
  // Step-4: Initialize worker run manager
  //================================
  if(mrm->GetUserActionInitialization())
    mrm->GetNonConstUserActionInitialization()->Build();
  if(mrm->GetUserWorkerInitialization())
    mrm->GetUserWorkerInitialization()->WorkerStart();
 
  workerRM()->Initialize();
 
  for(auto& itr : initCmdStack)
    G4UImanager::GetUIpointer()->ApplyCommand(itr);
 
  wrm->ProcessUI();
}

References G4UImanager::ApplyCommand(), PTL::TaskManager::async(), G4VUserActionInitialization::Build(), anonymous_namespace{G4TaskRunManagerKernel.cc}::context(), G4UserWorkerThreadInitialization::CreateWorkerRunManager(), G4Threading::G4SetThreadId(), PTL::get(), PTL::ThreadPool::get_this_thread_id(), G4MTRunManager::getMasterRandomEngine(), G4TaskRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterThreadId(), G4RunManager::GetNonConstUserActionInitialization(), G4MTRunManager::GetPinAffinity(), PTL::TaskRunManager::GetTaskManager(), PTL::TaskRunManager::GetThreadPool(), G4UImanager::GetUIpointer(), G4RunManager::GetUserActionInitialization(), G4RunManager::GetUserDetectorConstruction(), G4RunManager::GetUserPhysicsList(), G4RunManager::GetUserWorkerInitialization(), G4RunManager::GetUserWorkerThreadInitialization(), initCmdStack, G4VUserActionInitialization::InitializeSteppingVerbose(), InitializeWorker(), G4VSteppingVerbose::SetInstance(), G4UImanager::SetUpForAThread(), G4UserWorkerThreadInitialization::SetupRNGEngine(), PTL::ThreadPool::size(), G4UserWorkerInitialization::WorkerInitialize(), anonymous_namespace{G4TaskRunManagerKernel.cc}::workerRM(), G4UserWorkerInitialization::WorkerStart(), and G4Threading::WorkerThreadJoinsPool().

Referenced by G4TaskRunManager::CreateAndStartWorkers(), ExecuteWorkerInit(), ExecuteWorkerTask(), and InitializeWorker().

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().

SetUpDecayChannels()

void G4TaskRunManagerKernel::SetUpDecayChannels

(

)

Definition at line 336 of file G4TaskRunManagerKernel.cc.

{
  G4ParticleTable::G4PTblDicIterator* pItr =
    G4ParticleTable::GetParticleTable()->GetIterator();
  pItr->reset();
  while((*pItr)())
  {
    G4DecayTable* dt = pItr->value()->GetDecayTable();
    if(dt)
    {
      G4int nCh = dt->entries();
      for(G4int i = 0; i < nCh; i++)
      {
        dt->GetDecayChannel(i)->GetDaughter(0);
      }
    }
  }
}

References G4DecayTable::entries(), G4VDecayChannel::GetDaughter(), G4DecayTable::GetDecayChannel(), G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4ParticleTableIterator< K, V >::reset(), and G4ParticleTableIterator< K, V >::value().

Referenced by G4TaskRunManager::InitializeEventLoop().

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 G4TaskRunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented from G4RunManagerKernel.

Definition at line 94 of file G4TaskRunManagerKernel.cc.

{
  // Behavior is the same as base class (sequential mode)
  // ShadowProcess pointer == process poitner
  G4RunManagerKernel::SetupShadowProcess();
}

References G4RunManagerKernel::SetupShadowProcess().

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().

TerminateWorker() [1/2]

void G4TaskRunManagerKernel::TerminateWorker ( )

static

Definition at line 287 of file G4TaskRunManagerKernel.cc.

{
  if(workerRM())
    TerminateWorker(workerRM().get());
  workerRM().reset();
  context().reset();
}

References anonymous_namespace{G4TaskRunManagerKernel.cc}::context(), PTL::get(), TerminateWorker(), and anonymous_namespace{G4TaskRunManagerKernel.cc}::workerRM().

Referenced by TerminateWorker(), and G4TaskRunManager::TerminateWorkers().

TerminateWorker() [2/2]

void G4TaskRunManagerKernel::TerminateWorker ( G4WorkerTaskRunManager *  wrm )

static

Definition at line 309 of file G4TaskRunManagerKernel.cc.

{
  if(!wrm)
    return;
 
  //===============================
  // Step-6: Terminate worker thread
  //===============================
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  if(mrm && mrm->GetUserWorkerInitialization())
    mrm->GetUserWorkerInitialization()->WorkerStop();
 
  G4WorkerThread* _context = wrm->GetWorkerThread();
  _context->DestroyGeometryAndPhysicsVector();
 
  G4Threading::WorkerThreadLeavesPool();
}

References G4WorkerThread::DestroyGeometryAndPhysicsVector(), G4TaskRunManager::GetMasterRunManager(), G4RunManager::GetUserWorkerInitialization(), G4WorkerTaskRunManager::GetWorkerThread(), G4UserWorkerInitialization::WorkerStop(), and G4Threading::WorkerThreadLeavesPool().

TerminateWorkerRunEventLoop() [1/2]

void G4TaskRunManagerKernel::TerminateWorkerRunEventLoop ( )

static

Definition at line 279 of file G4TaskRunManagerKernel.cc.

{
  if(workerRM())
    TerminateWorkerRunEventLoop(workerRM().get());
}

References PTL::get(), TerminateWorkerRunEventLoop(), and anonymous_namespace{G4TaskRunManagerKernel.cc}::workerRM().

Referenced by TerminateWorkerRunEventLoop(), and G4TaskRunManager::WaitForEndEventLoopWorkers().

TerminateWorkerRunEventLoop() [2/2]

void G4TaskRunManagerKernel::TerminateWorkerRunEventLoop ( G4WorkerTaskRunManager *  wrm )

static

Definition at line 297 of file G4TaskRunManagerKernel.cc.

{
  if(!wrm)
    return;
 
  wrm->TerminateEventLoop();
  wrm->RunTermination();
}

References G4WorkerTaskRunManager::RunTermination(), and G4WorkerTaskRunManager::TerminateEventLoop().

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().

initCmdStack

std::vector< G4String > G4TaskRunManagerKernel::initCmdStack = {}

staticprotected

Definition at line 92 of file G4TaskRunManagerKernel.hh.

Referenced by InitCommandStack(), and InitializeWorker().

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/G4TaskRunManagerKernel.hh
• source/tasking/src/G4TaskRunManagerKernel.cc