#include <G4WorkerTaskRunManagerKernel.hh>

Inheritance diagram for G4WorkerTaskRunManagerKernel:

Public Member Functions
	G4WorkerTaskRunManagerKernel ()

virtual	~G4WorkerTaskRunManagerKernel ()

Public Member Functions inherited from G4RunManagerKernel
	G4RunManagerKernel ()

virtual	~G4RunManagerKernel ()

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

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

void	SetPhysics (G4VUserPhysicsList *uPhys)

void	InitializePhysics ()

G4bool	RunInitialization (G4bool fakeRun=false)

void	RunTermination ()

void	UpdateRegion ()

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=nullptr) const

void	WorkerUpdateWorldVolume ()

void	GeometryHasBeenModified ()

void	PhysicsHasBeenModified ()

G4EventManager *	GetEventManager () const

G4StackManager *	GetStackManager () const

G4TrackingManager *	GetTrackingManager () const

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

G4PrimaryTransformer *	GetPrimaryTransformer () const

const G4String &	GetVersionString () const

void	SetVerboseLevel (G4int vl)

void	SetGeometryToBeOptimized (G4bool vl)

G4int	GetNumberOfParallelWorld () const

void	SetNumberOfParallelWorld (G4int i)

G4VUserPhysicsList *	GetPhysicsList () const

G4VPhysicalVolume *	GetCurrentWorld () const

G4int	GetNumberOfStaticAllocators () const

Protected Member Functions
void	SetupShadowProcess () const

Protected Member Functions inherited from G4RunManagerKernel
	G4RunManagerKernel (RMKType rmkType)

void	SetupDefaultRegion ()

void	SetupPhysics ()

void	ResetNavigator ()

void	BuildPhysicsTables (G4bool fakeRun)

void	CheckRegions ()

virtual void	SetupShadowProcess () const

void	PropagateGenericIonID ()

Additional Inherited Members
Public Types inherited from G4RunManagerKernel
enum	RMKType { sequentialRMK , masterRMK , workerRMK }

Static Public Member Functions inherited from G4RunManagerKernel
static G4RunManagerKernel *	GetRunManagerKernel ()

Protected Attributes inherited from G4RunManagerKernel
RMKType	runManagerKernelType

G4Region *	defaultRegion = nullptr

G4Region *	defaultRegionForParallelWorld = nullptr

G4bool	geometryNeedsToBeClosed = true

Detailed Description

Definition at line 59 of file G4WorkerTaskRunManagerKernel.hh.

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
}

◆ ~G4WorkerTaskRunManagerKernel()

G4WorkerTaskRunManagerKernel::~G4WorkerTaskRunManagerKernel ( )

virtual

Definition at line 49 of file G4WorkerTaskRunManagerKernel.cc.

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

Member Function Documentation

◆ 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(G4int iv1 = 0; iv1 < (G4int)procs.size(); ++iv1)
        G4cout << "  " << iv1 << " - " << procs[iv1]->GetProcessName()
               << G4endl;
 
      G4cout << "--------------------------------------------------------------"
             << G4endl;
 
      for(G4int iv2 = 0; iv2 < (G4int)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(G4int idx = 0; idx < (G4int)procs.size(); ++idx)
    {
      procs[idx]->SetMasterProcess(procsM[idx]);
    }
  }
}

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

Public Member Functions