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

Static Public Member Functions
static G4TransportationManager *	GetTransportationManager ()

Protected Member Functions
	G4TransportationManager ()

	~G4TransportationManager ()

Detailed Description

Definition at line 57 of file G4TransportationManager.hh.

Constructor & Destructor Documentation

G4TransportationManager::G4TransportationManager ( )

protected

Definition at line 56 of file G4TransportationManager.cc.

References G4Navigator::Activate(), FatalException, G4Exception(), and G4Navigator::GetWorldVolume().

Referenced by GetTransportationManager().

 { 
   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 = new G4Navigator();
   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();
   fPropagatorInField= new G4PropagatorInField(trackingNavigator,fFieldManager);
   fSafetyHelper     = new G4SafetyHelper();
 } 

G4TransportationManager::~G4TransportationManager ( )

protected

Definition at line 82 of file G4TransportationManager.cc.

 {
   delete fFieldManager; 
   delete fPropagatorInField;
   ClearNavigators(); 
   delete fGeomMessenger;
   delete fSafetyHelper;
   if (fTransportationManager)
   {
     delete fTransportationManager; fTransportationManager=0;
   }
 }

Member Function Documentation

G4int G4TransportationManager::ActivateNavigator ( G4Navigator * aNavigator )

Definition at line 304 of file G4TransportationManager.cc.

References G4Navigator::Activate(), G4Exception(), G4VPhysicalVolume::GetName(), G4Navigator::GetWorldVolume(), and JustWarning.

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

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

void G4TransportationManager::DeActivateNavigator ( G4Navigator * aNavigator )

Definition at line 339 of file G4TransportationManager.cc.

References G4Exception(), G4VPhysicalVolume::GetName(), G4Navigator::GetWorldVolume(), and JustWarning.

Referenced by G4FastSimulationManagerProcess::EndTracking().

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

void G4TransportationManager::DeRegisterNavigator ( G4Navigator * aNavigator )

Definition at line 265 of file G4TransportationManager.cc.

References FatalException, G4Exception(), G4VPhysicalVolume::GetName(), G4Navigator::GetWorldVolume(), and JustWarning.

 {
    if (aNavigator == fNavigators[0])
    {
       G4Exception("G4TransportationManager::DeRegisterNavigator()",
                   "GeomNav0003", FatalException,
                   "The navigator for tracking CANNOT be deregistered!");
    }
    std::vector<G4Navigator*>::iterator pNav =
      std::find(fNavigators.begin(), fNavigators.end(), aNavigator);
    if (pNav != fNavigators.end())
    {
       // 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);
    }
 }

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

inline

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

G4FieldManager* G4TransportationManager::GetFieldManager ( ) const

inline

Referenced by G4ErrorSurfaceTrajState::BuildErrorMatrix(), CCalDetectorConstruction::Construct(), RE05DetectorConstruction::ConstructSDandField(), F05DetectorConstruction::ConstructSDandField(), F06DetectorConstruction::ConstructSDandField(), DetectorConstruction::ConstructSDandField(), G4MagneticFieldModel::DescribeYourselfTo(), G4ITTransportation::DoesGlobalFieldExist(), export_G4TransportationManager(), G4CoupledTransportation::G4CoupledTransportation(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), ExErrorMagneticField::GetGlobalFieldManager(), ExN02MagneticField::GetGlobalFieldManager(), ExP01MagneticField::GetGlobalFieldManager(), F03FieldSetup::GetGlobalFieldManager(), F02ElectricFieldSetup::GetGlobalFieldManager(), F01FieldSetup::GetGlobalFieldManager(), F04GlobalField::GetGlobalFieldManager(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4MonopoleFieldSetup::InitialiseAll(), F01FieldSetup::InitialiseAll(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4ErrorFreeTrajState::PropagateError(), DetectorConstruction::SetMagField(), ExN03DetectorConstruction::SetMagField(), and GammaRayTelDetectorConstruction::SetMagField().

G4Navigator * G4TransportationManager::GetNavigator ( const G4String & worldName )

Definition at line 189 of file G4TransportationManager.cc.

References FatalException, G4Exception(), IsWorldExisting(), and G4Navigator::SetWorldVolume().

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

 {
    // If already existing, return the stored pointer to the navigator
    //
    std::vector<G4Navigator*>::iterator pNav;
    for (pNav=fNavigators.begin(); pNav!=fNavigators.end(); pNav++)
    {
       if ((*pNav)->GetWorldVolume()->GetName() == worldName) { return *pNav; }
    }
 
    // Check if world of that name already exists,
    // create a navigator and register it
    //
    G4Navigator* aNavigator = 0;
    G4VPhysicalVolume* aWorld = IsWorldExisting(worldName);
    if(aWorld)
    {
       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;
 }

G4Navigator * G4TransportationManager::GetNavigator ( G4VPhysicalVolume * aWorld )

Definition at line 229 of file G4TransportationManager.cc.

References FatalException, G4Exception(), G4VPhysicalVolume::GetName(), and G4Navigator::SetWorldVolume().

 {
    std::vector<G4Navigator*>::iterator pNav;
    for (pNav=fNavigators.begin(); pNav!=fNavigators.end(); pNav++)
    {
      if ((*pNav)->GetWorldVolume() == aWorld) { return *pNav; }
    }
    G4Navigator* aNavigator = 0;
    std::vector<G4VPhysicalVolume*>::iterator pWorld =
      std::find(fWorlds.begin(), fWorlds.end(), aWorld);
    if (pWorld != fWorlds.end())
    {
       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;
 }

G4Navigator* G4TransportationManager::GetNavigatorForTracking ( ) const

inline

Referenced by G4RayTrajectory::AppendStep(), G4MultiNavigator::CheckMassWorld(), G4TheRayTracer::CreateBitMap(), G4MagneticFieldModel::DescribeYourselfTo(), DMXParticleSource::DMXParticleSource(), DMXStackingAction::DMXStackingAction(), G4TrajectoryDrawByOriginVolume::Draw(), G4PathFinder::EnableParallelNavigation(), G4ASCIITreeSceneHandler::EndModeling(), G4TrajectoryOriginVolumeFilter::Evaluate(), export_G4TransportationManager(), G4CoupledTransportation::G4CoupledTransportation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4MonopoleTransportation::G4MonopoleTransportation(), G4MultiNavigator::G4MultiNavigator(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4SPSPosDistribution::G4SPSPosDistribution(), G4Transportation::G4Transportation(), GetParallelWorld(), G4SafetyHelper::InitialiseNavigator(), G4FastSimulationManager::ListTitle(), G4VTransitionRadiation::PostStepDoIt(), G4WeightWindowStore::SetWorldVolume(), G4IStore::SetWorldVolume(), G4FastSimulationManagerProcess::StartTracking(), and G4CoupledTransportation::StartTracking().

size_t G4TransportationManager::GetNoActiveNavigators ( ) const

inline

size_t G4TransportationManager::GetNoWorlds ( ) const

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4MTRunManager::ConstructScoringWorlds(), G4VisCommandSceneAddVolume::SetNewValue(), and G4PhysicalVolumeModel::Validate().

G4VPhysicalVolume * G4TransportationManager::GetParallelWorld ( const G4String & worldName )

Definition at line 165 of file G4TransportationManager.cc.

References G4VPhysicalVolume::GetLogicalVolume(), GetNavigatorForTracking(), G4LogicalVolume::GetSolid(), G4Navigator::GetWorldVolume(), IsWorldExisting(), and RegisterWorld().

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

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

G4PropagatorInField* G4TransportationManager::GetPropagatorInField ( ) const

inline

Referenced by G4BlineTracer::ComputeBlines(), CCalDetectorConstruction::Construct(), F04GlobalField::ConstructField(), F05DetectorConstruction::ConstructSDandField(), F06DetectorConstruction::ConstructSDandField(), DetectorConstruction::ConstructSDandField(), G4DecayWithSpin::DecayIt(), export_G4TransportationManager(), G4CoupledTransportation::G4CoupledTransportation(), G4ITTransportation::G4ITTransportation(), G4MonopoleTransportation::G4MonopoleTransportation(), G4PathFinder::G4PathFinder(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4Transportation::G4Transportation(), DetectorConstruction::SetMaxStepLength(), and G4TrackingMessenger::SetNewValue().

G4SafetyHelper* G4TransportationManager::GetSafetyHelper ( ) const

inline

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

G4TransportationManager * G4TransportationManager::GetTransportationManager ( )

static

Definition at line 100 of file G4TransportationManager.cc.

References G4TransportationManager().

Referenced by G4Scene::AddWorldIfEmpty(), G4RayTrajectory::AppendStep(), G4ErrorSurfaceTrajState::BuildErrorMatrix(), G4RunManagerKernel::CheckRegions(), G4VPrimaryGenerator::CheckVertexInsideWorld(), HepMCG4Interface::CheckVertexInsideWorld(), G4BlineTracer::ComputeBlines(), CCalDetectorConstruction::Construct(), H02DetectorConstruction::Construct(), ExN04DetectorConstruction::Construct(), F04ElementField::Construct(), F04GlobalField::ConstructField(), G4ParallelWorldPhysics::ConstructProcess(), G4WorkerRunManager::ConstructScoringWorlds(), G4MTRunManager::ConstructScoringWorlds(), G4RunManager::ConstructScoringWorlds(), RE05DetectorConstruction::ConstructSDandField(), F05DetectorConstruction::ConstructSDandField(), F06DetectorConstruction::ConstructSDandField(), DetectorConstruction::ConstructSDandField(), G4TheRayTracer::CreateBitMap(), G4DecayWithSpin::DecayIt(), G4RunManagerKernel::DefineWorldVolume(), G4MagneticFieldModel::DescribeYourselfTo(), DMXParticleSource::DMXParticleSource(), DMXStackingAction::DMXStackingAction(), G4ITTransportation::DoesGlobalFieldExist(), G4TrajectoryDrawByOriginVolume::Draw(), G4DrawVoxels::DrawVoxels(), G4ASCIITreeSceneHandler::EndModeling(), G4CoupledTransportation::EndTracking(), G4TrajectoryOriginVolumeFilter::Evaluate(), export_G4TransportationManager(), G4CoupledTransportation::G4CoupledTransportation(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4MonopoleTransportation::G4MonopoleTransportation(), G4MultiNavigator::G4MultiNavigator(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PathFinder::G4PathFinder(), G4SPSPosDistribution::G4SPSPosDistribution(), G4SteppingManager::G4SteppingManager(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4Transportation::G4Transportation(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), F04PrimaryGeneratorAction::GeneratePrimaries(), G4VisManager::GeometryHasChanged(), ExErrorMagneticField::GetGlobalFieldManager(), ExN02MagneticField::GetGlobalFieldManager(), ExP01MagneticField::GetGlobalFieldManager(), F03FieldSetup::GetGlobalFieldManager(), F02ElectricFieldSetup::GetGlobalFieldManager(), F01FieldSetup::GetGlobalFieldManager(), F04GlobalField::GetGlobalFieldManager(), G4VMscModel::GetParticleChangeForMSC(), G4VUserParallelWorld::GetWorld(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4MonopoleFieldSetup::InitialiseAll(), F01FieldSetup::InitialiseAll(), G4SafetyHelper::InitialiseNavigator(), G4BOptnForceCommonTruncatedExp::Initialize(), G4ErrorRunManagerHelper::InitializeGeometry(), G4FastSimulationManager::ListTitle(), main(), GFlashHitMaker::make(), G4VTransitionRadiation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4VMultipleScattering::PreparePhysicsTable(), G4ErrorFreeTrajState::PropagateError(), DetectorConstruction::SetMagField(), ExN03DetectorConstruction::SetMagField(), GammaRayTelDetectorConstruction::SetMagField(), DetectorConstruction::SetMaxStepLength(), G4TrackingMessenger::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4WeightWindowStore::SetParallelWorldVolume(), G4IStore::SetParallelWorldVolume(), G4RTPrimaryGeneratorAction::SetUp(), G4WeightWindowStore::SetWorldVolume(), G4IStore::SetWorldVolume(), G4GlobalFastSimulationManager::ShowSetup(), G4FastSimulationManagerProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4PhysicalVolumeModel::Validate(), G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

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

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

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4MTRunManager::ConstructScoringWorlds(), G4VisCommandSceneAddVolume::SetNewValue(), and G4PhysicalVolumeModel::Validate().

void G4TransportationManager::InactivateAll ( )

Definition at line 370 of file G4TransportationManager.cc.

Referenced by G4CoupledTransportation::EndTracking().

 {
    std::vector<G4Navigator*>::iterator pNav;
    for (pNav=fActiveNavigators.begin(); pNav!=fActiveNavigators.end(); pNav++)
    {
       (*pNav)->Activate(false);
    }
    fActiveNavigators.clear();
 
    // Restore status for the navigator for tracking
    //
    fNavigators[0]->Activate(true);
    fActiveNavigators.push_back(fNavigators[0]);
 }

G4VPhysicalVolume * G4TransportationManager::IsWorldExisting ( const G4String & worldName )

Definition at line 392 of file G4TransportationManager.cc.

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

 {
    std::vector<G4VPhysicalVolume*>::iterator pWorld = fWorlds.begin();
    if (*pWorld==0)  { *pWorld=fNavigators[0]->GetWorldVolume(); }
 
    for (pWorld=fWorlds.begin(); pWorld!=fWorlds.end(); pWorld++)
    {
       if ((*pWorld)->GetName() == name ) { return *pWorld; }
    }
    return 0;
 }

G4bool G4TransportationManager::RegisterWorld ( G4VPhysicalVolume * aWorld )

Definition at line 411 of file G4TransportationManager.cc.

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

 {
    G4bool done = false;
 
    std::vector<G4VPhysicalVolume*>::iterator pWorld =
      std::find(fWorlds.begin(), fWorlds.end(), aWorld);
    if (pWorld == fWorlds.end())
    {
      fWorlds.push_back(aWorld);
      done = true;
    }
    return done;
 }

void G4TransportationManager::SetFieldManager ( G4FieldManager * newFieldManager )

Definition at line 114 of file G4TransportationManager.cc.

Referenced by export_G4TransportationManager().

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

void G4TransportationManager::SetNavigatorForTracking ( G4Navigator * newNavigator )

Definition at line 133 of file G4TransportationManager.cc.

References G4PropagatorInField::SetNavigatorForPropagating().

Referenced by export_G4TransportationManager().

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

void G4TransportationManager::SetPropagatorInField ( G4PropagatorInField * newFieldPropagator )

inline

Referenced by export_G4TransportationManager().

void G4TransportationManager::SetWorldForTracking ( G4VPhysicalVolume * theWorld )

inline

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation