#include <G4WorkerRunManagerKernel.hh>

Inheritance diagram for G4WorkerRunManagerKernel:

Public Member Functions
	G4WorkerRunManagerKernel ()

virtual	~G4WorkerRunManagerKernel ()

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

void	UpdateRegion ()

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=0) const

void	GeometryHasBeenModified ()

void	PhysicsHasBeenModified ()

G4EventManager *	GetEventManager () const

G4StackManager *	GetStackManager () const

G4TrackingManager *	GetTrackingManager () const

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

G4PrimaryTransformer *	GetPrimaryTransformer () const

const G4String &	GetVersionString () const

void	SetVerboseLevel (G4int vl)

void	SetGeometryToBeOptimized (G4bool vl)

G4int	GetNumberOfParallelWorld () const

void	SetNumberOfParallelWorld (G4int i)

G4VUserPhysicsList *	GetPhysicsList () const

G4VPhysicalVolume *	GetCurrentWorld () const

G4int	GetNumberOfStaticAllocators () const

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

G4Region *	defaultRegionForParallelWorld

G4bool	geometryNeedsToBeClosed

Detailed Description

Definition at line 59 of file G4WorkerRunManagerKernel.hh.

Constructor & Destructor Documentation

◆ G4WorkerRunManagerKernel()

G4WorkerRunManagerKernel::G4WorkerRunManagerKernel ( )

Definition at line 30 of file G4WorkerRunManagerKernel.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
}

◆ ~G4WorkerRunManagerKernel()

G4WorkerRunManagerKernel::~G4WorkerRunManagerKernel ( )

virtual

Definition at line 46 of file G4WorkerRunManagerKernel.cc.

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

Member Function Documentation

◆ SetupShadowProcess()

void G4WorkerRunManagerKernel::SetupShadowProcess ( ) const

protectedvirtual

Reimplemented from G4RunManagerKernel.

Definition at line 51 of file G4WorkerRunManagerKernel.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("G4WorkerRunManagerKernel::SetupShadowProcess()", "Run0116",
                  FatalException, msg);
      return;
    }
    G4ProcessVector& procs  = *(pm->GetProcessList());
    G4ProcessVector& procsM = *(pmM->GetProcessList());
    if(procs.size() != procsM.size())
    {
      G4cout << "G4WorkerRunManagerKernel::SetupShadowProcess() for particle <"
             << pd->GetParticleName() << ">" << G4endl;
      G4cout << " ProcessManager : " << pm << " ProcessManagerShadow : " << pmM
             << G4endl;
      for(std::size_t iv1 = 0; iv1 < procs.size(); ++iv1)
      {
        G4cout << "  " << iv1 << " - " << procs[iv1]->GetProcessName()
               << G4endl;
      }
      G4cout << "--------------------------------------------------------------"
             << G4endl;
      for(std::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("G4WorkerRunManagerKernel::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(std::size_t idx = 0; idx < procs.size(); ++idx)
    {
      procs[idx]->SetMasterProcess(procsM[idx]);
    }
  }
}

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

Public Member Functions