G4TransportationManager Class Reference

#include <G4TransportationManager.hh>

Public Member Functions
G4PropagatorInField *	GetPropagatorInField () const
void	SetPropagatorInField (G4PropagatorInField *newFieldPropagator)
G4FieldManager *	GetFieldManager () const
void	SetFieldManager (G4FieldManager *newFieldManager)
G4Navigator *	GetNavigatorForTracking () const
void	SetNavigatorForTracking (G4Navigator *newNavigator)
void	SetWorldForTracking (G4VPhysicalVolume *theWorld)
size_t	GetNoActiveNavigators () const
std::vector< G4Navigator * >::iterator	GetActiveNavigatorsIterator ()
size_t	GetNoWorlds () const
std::vector< G4VPhysicalVolume * >::iterator	GetWorldsIterator ()
G4SafetyHelper *	GetSafetyHelper () const
G4VPhysicalVolume *	GetParallelWorld (const G4String &worldName)
G4VPhysicalVolume *	IsWorldExisting (const G4String &worldName)
G4Navigator *	GetNavigator (const G4String &worldName)
G4Navigator *	GetNavigator (G4VPhysicalVolume *aWorld)
G4bool	RegisterWorld (G4VPhysicalVolume *aWorld)
void	DeRegisterNavigator (G4Navigator *aNavigator)
G4int	ActivateNavigator (G4Navigator *aNavigator)
void	DeActivateNavigator (G4Navigator *aNavigator)
void	InactivateAll ()
void	ClearParallelWorlds ()
	~G4TransportationManager ()

Static Public Member Functions
static G4TransportationManager *	GetTransportationManager ()
static G4TransportationManager *	GetInstanceIfExist ()
static G4Navigator *	GetFirstTrackingNavigator ()
static void	SetFirstTrackingNavigator (G4Navigator *nav)

Protected Member Functions
	G4TransportationManager ()

Detailed Description

Definition at line 53 of file G4TransportationManager.hh.

Constructor & Destructor Documentation

~G4TransportationManager()

G4TransportationManager::~G4TransportationManager

(

)

Definition at line 90 of file G4TransportationManager.cc.

{
  delete fSafetyHelper;
  delete fPropagatorInField;
  delete fGeomMessenger;
  ClearNavigators();
  fTransportationManager = nullptr; 
}

G4TransportationManager()

G4TransportationManager::G4TransportationManager ( )

protected

Definition at line 54 of file G4TransportationManager.cc.

{ 
  if (fTransportationManager)
  {
    G4Exception("G4TransportationManager::G4TransportationManager()",
                "GeomNav0002", FatalException,
                "Only ONE instance of G4TransportationManager is allowed!");
  }
 
  // Create the navigator for tracking and activate it; add to collections
  //
  G4Navigator* trackingNavigator= nullptr; 
  if( fFirstTrackingNavigator && fFirstTrackingNavigator->GetExternalNavigation() )
  {
     trackingNavigator = fFirstTrackingNavigator->Clone();
  }
  else
  {
     trackingNavigator = new G4Navigator();
     if( fFirstTrackingNavigator == nullptr ) 
        fFirstTrackingNavigator = trackingNavigator;
  }
  trackingNavigator->Activate(true);
  fNavigators.push_back(trackingNavigator);
  fActiveNavigators.push_back(trackingNavigator);
  fWorlds.push_back(trackingNavigator->GetWorldVolume()); // NULL registered
 
  fGeomMessenger    = new G4GeometryMessenger(this);
  fFieldManager     = new G4FieldManager(); // deleted by G4FieldManagerStore
  fPropagatorInField= new G4PropagatorInField(trackingNavigator,fFieldManager);
  fSafetyHelper     = new G4SafetyHelper();
} 

Referenced by GetTransportationManager().

Member Function Documentation

ActivateNavigator()

G4int G4TransportationManager::ActivateNavigator

(

G4Navigator *

aNavigator

)

Definition at line 313 of file G4TransportationManager.cc.

{
   auto pNav = std::find(fNavigators.cbegin(), fNavigators.cend(), aNavigator);
   if (pNav == fNavigators.cend())
   {
      G4String message
         = "Navigator for volume -" + aNavigator->GetWorldVolume()->GetName()
         + "- not found in memory!";      
      G4Exception("G4TransportationManager::ActivateNavigator()",
                  "GeomNav1002", FatalException, message);
      return -1;
   }
 
   aNavigator->Activate(true);
   G4int id = 0;
   for(auto pActiveNav=fActiveNavigators.cbegin();
       pActiveNav!=fActiveNavigators.cend(); ++pActiveNav)
   {
      if (*pActiveNav == aNavigator)  { return id; }
      ++id;
   }
   
   fActiveNavigators.push_back(aNavigator);
   return id;
}

Referenced by G4CoupledTransportation::G4CoupledTransportation(), G4SafetyHelper::InitialiseNavigator(), G4ParallelGeometriesLimiterProcess::StartTracking(), G4ImportanceProcess::StartTracking(), G4WeightCutOffProcess::StartTracking(), G4WeightWindowProcess::StartTracking(), G4FastSimulationManagerProcess::StartTracking(), G4ParallelWorldProcess::StartTracking(), G4ParallelWorldScoringProcess::StartTracking(), and G4CoupledTransportation::StartTracking().

ClearParallelWorlds()

void G4TransportationManager::ClearParallelWorlds

(

)

Definition at line 461 of file G4TransportationManager.cc.

{
   auto pNav = fNavigators.cbegin();
   G4Navigator* trackingNavigator = *pNav;
   for (pNav=fNavigators.cbegin(); pNav!=fNavigators.cend(); ++pNav)
   {
     if (*pNav != trackingNavigator)  { delete *pNav; }
   }
   fNavigators.clear();
   fActiveNavigators.clear();
   fWorlds.clear();
 
   fNavigators.push_back(trackingNavigator);
   fActiveNavigators.push_back(trackingNavigator);
   fWorlds.push_back(0); // NULL registered
}

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

DeActivateNavigator()

void G4TransportationManager::DeActivateNavigator

(

G4Navigator *

aNavigator

)

Definition at line 346 of file G4TransportationManager.cc.

{
   auto pNav = std::find(fNavigators.cbegin(), fNavigators.cend(), aNavigator);
   if (pNav != fNavigators.cend())
   {
      (*pNav)->Activate(false);
   }
   else
   {
      G4String message
         = "Navigator for volume -" + aNavigator->GetWorldVolume()->GetName()
         + "- not found in memory!";
      G4Exception("G4TransportationManager::DeActivateNavigator()",
                  "GeomNav1002", JustWarning, message);
   }
 
   auto pActiveNav = std::find(fActiveNavigators.cbegin(),
                               fActiveNavigators.cend(), aNavigator);
   if (pActiveNav != fActiveNavigators.cend())
   {
      fActiveNavigators.erase(pActiveNav);
   }
}

Referenced by G4ParallelGeometriesLimiterProcess::EndTracking(), and G4FastSimulationManagerProcess::EndTracking().

DeRegisterNavigator()

void G4TransportationManager::DeRegisterNavigator

(

G4Navigator *

aNavigator

)

Definition at line 275 of file G4TransportationManager.cc.

{
   if (aNavigator == fNavigators[0])
   {
      G4Exception("G4TransportationManager::DeRegisterNavigator()",
                  "GeomNav0003", FatalException,
                  "The navigator for tracking CANNOT be deregistered!");
   }
   auto pNav = std::find(fNavigators.cbegin(), fNavigators.cend(), aNavigator);
   if (pNav != fNavigators.cend())
   {
      // Deregister associated world volume
      //
      DeRegisterWorld((*pNav)->GetWorldVolume());
 
      // Deregister the navigator
      //
      fNavigators.erase(pNav);
   }
   else
   {
      G4String message
         = "Navigator for volume -" + aNavigator->GetWorldVolume()->GetName()
         + "- not found in memory!";      
      G4Exception("G4TransportationManager::DeRegisterNavigator()",
                  "GeomNav1002", JustWarning, message);
   }
}

GetActiveNavigatorsIterator()

std::vector< G4Navigator * >::iterator G4TransportationManager::GetActiveNavigatorsIterator ( )

inline

Referenced by G4PathFinder::ComputeSafety(), G4MultiNavigator::GetGlobalExitNormal(), G4PathFinder::Locate(), G4MultiNavigator::LocateGlobalPointAndSetup(), G4MultiNavigator::LocateGlobalPointWithinVolume(), G4OpBoundaryProcess::PostStepDoIt(), G4MultiNavigator::PrepareNavigators(), G4PathFinder::PrepareNewTrack(), G4PathFinder::ReLocate(), and G4MultiNavigator::ResetHierarchyAndLocate().

GetFieldManager()

G4FieldManager * G4TransportationManager::GetFieldManager ( ) const

inline

Referenced by G4ErrorSurfaceTrajState::BuildErrorMatrix(), G4VFieldModel::DescribeYourselfTo(), G4ITTransportation::DoesGlobalFieldExist(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), and G4ErrorFreeTrajState::PropagateError().

GetFirstTrackingNavigator()

G4Navigator * G4TransportationManager::GetFirstTrackingNavigator ( )

static

Definition at line 483 of file G4TransportationManager.cc.

{
  return fFirstTrackingNavigator;
}

GetInstanceIfExist()

G4TransportationManager * G4TransportationManager::GetInstanceIfExist ( )

static

Definition at line 118 of file G4TransportationManager.cc.

{
   return fTransportationManager;
}

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

GetNavigator() [1/2]

G4Navigator * G4TransportationManager::GetNavigator

(

const G4String &

worldName

)

Definition at line 202 of file G4TransportationManager.cc.

{
   // If already existing, return the stored pointer to the navigator
   //
   for (auto pNav=fNavigators.cbegin(); pNav!=fNavigators.cend(); ++pNav)
   {
      if ((*pNav)->GetWorldVolume()->GetName() == worldName) { return *pNav; }
   }
 
   // Check if world of that name already exists,
   // create a navigator and register it
   //
   G4Navigator* aNavigator = nullptr;
   G4VPhysicalVolume* aWorld = IsWorldExisting(worldName);
   if(aWorld != nullptr)
   {
      aNavigator = new G4Navigator();
      aNavigator->SetWorldVolume(aWorld);
      fNavigators.push_back(aNavigator);
   }
   else
   {
      G4String message
         = "World volume with name -" + worldName
         + "- does not exist. Create it first by GetParallelWorld() method!";      
      G4Exception("G4TransportationManager::GetNavigator(name)",
                  "GeomNav0002", FatalException, message);
   }
 
   return aNavigator;
}

Referenced by G4ImportanceProcess::SetParallelWorld(), G4WeightCutOffProcess::SetParallelWorld(), G4WeightWindowProcess::SetParallelWorld(), G4ParallelWorldProcess::SetParallelWorld(), G4ParallelWorldScoringProcess::SetParallelWorld(), and G4FastSimulationManagerProcess::StartTracking().

GetNavigator() [2/2]

G4Navigator * G4TransportationManager::GetNavigator

(

G4VPhysicalVolume *

aWorld

)

Definition at line 241 of file G4TransportationManager.cc.

{
   for (auto pNav=fNavigators.cbegin(); pNav!=fNavigators.cend(); ++pNav)
   {
     if ((*pNav)->GetWorldVolume() == aWorld) { return *pNav; }
   }
   G4Navigator* aNavigator = nullptr;
   auto pWorld = std::find(fWorlds.cbegin(), fWorlds.cend(), aWorld);
   if (pWorld != fWorlds.cend())
   {
      aNavigator = new G4Navigator();
      aNavigator->SetWorldVolume(aWorld);
      fNavigators.push_back(aNavigator);
   }
   else
   {
      G4String message
         = "World volume with name -" + aWorld->GetName()
         + "- does not exist. Create it first by GetParallelWorld() method!";
      G4Exception("G4TransportationManager::GetNavigator(pointer)",
                  "GeomNav0002", FatalException, message);
   }
 
   return aNavigator;
}

GetNavigatorForTracking()

G4Navigator * G4TransportationManager::GetNavigatorForTracking ( ) const

inline

Referenced by G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4RayTrajectory::AppendStep(), G4MultiNavigator::CheckMassWorld(), G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), G4TheRayTracer::CreateBitMap(), G4VFieldModel::DescribeYourselfTo(), G4TrajectoryDrawByOriginVolume::Draw(), G4PathFinder::EnableParallelNavigation(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4CoupledTransportation::G4CoupledTransportation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4MultiNavigator::G4MultiNavigator(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4Transportation::G4Transportation(), GetParallelWorld(), G4SafetyHelper::InitialiseNavigator(), G4FastSimulationManager::ListTitle(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4VTransitionRadiation::PostStepDoIt(), G4IStore::SetWorldVolume(), G4WeightWindowStore::SetWorldVolume(), G4FastSimulationManagerProcess::StartTracking(), and G4CoupledTransportation::StartTracking().

GetNoActiveNavigators()

size_t G4TransportationManager::GetNoActiveNavigators ( ) const

inline

GetNoWorlds()

size_t G4TransportationManager::GetNoWorlds ( ) const

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4MTRunManager::ConstructScoringWorlds(), G4TaskRunManager::ConstructScoringWorlds(), G4TouchableUtils::FindTouchableProperties(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), and G4PhysicalVolumeModel::Validate().

GetParallelWorld()

G4VPhysicalVolume * G4TransportationManager::GetParallelWorld

(

const G4String &

worldName

)

Definition at line 178 of file G4TransportationManager.cc.

{
   G4VPhysicalVolume* wPV = IsWorldExisting(worldName);
   if (wPV == nullptr)
   {
     wPV = GetNavigatorForTracking()->GetWorldVolume();
     G4LogicalVolume* wLV = wPV->GetLogicalVolume();
     wLV = new G4LogicalVolume(wLV->GetSolid(), nullptr,
                               worldName);
     wPV = new G4PVPlacement (wPV->GetRotation(),
                              wPV->GetTranslation(),
                              wLV, worldName, nullptr, false, 0);
     RegisterWorld(wPV);
   }
   return wPV;
}

Referenced by G4ParallelWorldPhysics::ConstructProcess(), G4RunManager::ConstructScoringWorlds(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4VUserParallelWorld::GetWorld(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4ImportanceProcess::SetParallelWorld(), G4WeightCutOffProcess::SetParallelWorld(), G4WeightWindowProcess::SetParallelWorld(), G4ParallelWorldProcess::SetParallelWorld(), G4ParallelWorldScoringProcess::SetParallelWorld(), G4IStore::SetParallelWorldVolume(), and G4WeightWindowStore::SetParallelWorldVolume().

GetPropagatorInField()

G4PropagatorInField * G4TransportationManager::GetPropagatorInField ( ) const

inline

Referenced by G4DecayWithSpin::AtRestDoIt(), G4CoupledTransportation::G4CoupledTransportation(), G4ITTransportation::G4ITTransportation(), G4PathFinder::G4PathFinder(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4Transportation::G4Transportation(), and G4TrackingMessenger::SetNewValue().

GetSafetyHelper()

G4SafetyHelper * G4TransportationManager::GetSafetyHelper ( ) const

inline

Referenced by G4PathFinder::EnableParallelNavigation(), G4CoupledTransportation::G4CoupledTransportation(), G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess(), G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess(), G4NeutrinoElectronProcess::G4NeutrinoElectronProcess(), G4Transportation::G4Transportation(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMscModel::GetParticleChangeForMSC(), G4PathFinder::PrepareNewTrack(), and G4VMultipleScattering::PreparePhysicsTable().

GetTransportationManager()

G4TransportationManager * G4TransportationManager::GetTransportationManager ( )

static

Definition at line 104 of file G4TransportationManager.cc.

{
   if (fTransportationManager == nullptr)
   {
     fTransportationManager = new G4TransportationManager;
   }   
   return fTransportationManager;
}

Referenced by G4Scene::AddWorldIfEmpty(), G4RayTrajectory::AppendStep(), G4DecayWithSpin::AtRestDoIt(), G4ErrorSurfaceTrajState::BuildErrorMatrix(), G4RunManagerKernel::CheckRegions(), G4VPrimaryGenerator::CheckVertexInsideWorld(), G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), G4ParallelWorldPhysics::ConstructProcess(), G4MTRunManager::ConstructScoringWorlds(), G4RunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), G4TaskRunManager::ConstructScoringWorlds(), G4TheRayTracer::CreateBitMap(), G4RunManagerKernel::DefineWorldVolume(), G4VFieldModel::DescribeYourselfTo(), G4ITTransportation::DoesGlobalFieldExist(), G4TrajectoryDrawByOriginVolume::Draw(), G4DrawVoxels::DrawVoxels(), G4CoupledTransportation::EndTracking(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4TouchableUtils::FindTouchableProperties(), G4CoupledTransportation::G4CoupledTransportation(), G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4MultiNavigator::G4MultiNavigator(), G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess(), G4NeutrinoElectronProcess::G4NeutrinoElectronProcess(), G4ParallelGeometriesLimiterProcess::G4ParallelGeometriesLimiterProcess(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PathFinder::G4PathFinder(), G4SteppingManager::G4SteppingManager(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4Transportation::G4Transportation(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VisManager::GeometryHasChanged(), G4VMscModel::GetParticleChangeForMSC(), G4VUserParallelWorld::GetWorld(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4TDNAOneStepThermalizationModel< MODEL >::Initialise(), G4SafetyHelper::InitialiseNavigator(), G4BOptnForceCommonTruncatedExp::Initialize(), G4ErrorRunManagerHelper::InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), G4FastSimulationManager::ListTitle(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4UCNBoundaryProcess::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4VMultipleScattering::PreparePhysicsTable(), G4ErrorFreeTrajState::PropagateError(), G4RunManager::ReinitializeGeometry(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4TrackingMessenger::SetNewValue(), G4IStore::SetParallelWorldVolume(), G4WeightWindowStore::SetParallelWorldVolume(), G4RTPrimaryGeneratorAction::SetUp(), G4IStore::SetWorldVolume(), G4WeightWindowStore::SetWorldVolume(), G4GlobalFastSimulationManager::ShowSetup(), G4FastSimulationManagerProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4PhysicalVolumeModel::Validate(), G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

GetWorldsIterator()

std::vector< G4VPhysicalVolume * >::iterator G4TransportationManager::GetWorldsIterator ( )

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4MTRunManager::ConstructScoringWorlds(), G4TaskRunManager::ConstructScoringWorlds(), G4TouchableUtils::FindTouchableProperties(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), and G4PhysicalVolumeModel::Validate().

InactivateAll()

void G4TransportationManager::InactivateAll

(

)

Definition at line 376 of file G4TransportationManager.cc.

{
   for (auto pNav=fActiveNavigators.cbegin();
             pNav!=fActiveNavigators.cend(); ++pNav)
   {
      (*pNav)->Activate(false);
   }
   fActiveNavigators.clear();
 
   // Restore status for the navigator for tracking
   //
   fNavigators[0]->Activate(true);
   fActiveNavigators.push_back(fNavigators[0]);
}

Referenced by G4CoupledTransportation::EndTracking().

IsWorldExisting()

G4VPhysicalVolume * G4TransportationManager::IsWorldExisting

(

const G4String &

worldName

)

Definition at line 398 of file G4TransportationManager.cc.

{
   auto pWorld = fWorlds.begin();
   if ( *pWorld==nullptr )  { *pWorld=fNavigators[0]->GetWorldVolume(); }
 
   for (auto cpWorld=fWorlds.cbegin(); cpWorld!=fWorlds.cend(); ++cpWorld)
   {
      if ((*cpWorld)->GetName() == name ) { return *cpWorld; }
   }
   return 0;
}

Referenced by G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4RunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), GetNavigator(), GetParallelWorld(), G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4FastSimulationManagerProcess::SetWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

RegisterWorld()

G4bool G4TransportationManager::RegisterWorld

(

G4VPhysicalVolume *

aWorld

)

Definition at line 417 of file G4TransportationManager.cc.

{
   G4bool done = false;
 
   auto pWorld = std::find(fWorlds.cbegin(), fWorlds.cend(), aWorld);
   if (pWorld == fWorlds.cend())
   {
     fWorlds.push_back(aWorld);
     done = true;
   }
   return done;
}

Referenced by GetParallelWorld(), G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

SetFieldManager()

void G4TransportationManager::SetFieldManager

(

G4FieldManager *

newFieldManager

)

Definition at line 128 of file G4TransportationManager.cc.

{
   fFieldManager = newFieldManager; 
 
   // Message the PropagatorInField, 
   // which also maintains this information (to be reviewed)
   //
   if( fPropagatorInField )
   {
      fPropagatorInField -> SetDetectorFieldManager( newFieldManager );
   }
}

SetFirstTrackingNavigator()

void G4TransportationManager::SetFirstTrackingNavigator ( G4Navigator *  nav )

static

Definition at line 493 of file G4TransportationManager.cc.

{
  fFirstTrackingNavigator= nav;
}

SetNavigatorForTracking()

void G4TransportationManager::SetNavigatorForTracking

(

G4Navigator *

newNavigator

)

Definition at line 147 of file G4TransportationManager.cc.

{
   fNavigators[0] = newNavigator;
   fActiveNavigators[0] = newNavigator;
   fPropagatorInField->SetNavigatorForPropagating(newNavigator);
}

SetPropagatorInField()

void G4TransportationManager::SetPropagatorInField ( G4PropagatorInField *  newFieldPropagator )

inline

SetWorldForTracking()

void G4TransportationManager::SetWorldForTracking ( G4VPhysicalVolume *  theWorld )

inline

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

---

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

• G4TransportationManager.hh
• G4TransportationManager.cc