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)
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::G4TransportationManager ( )

protected

Definition at line 55 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 = 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::~G4TransportationManager ( )

protected

Definition at line 81 of file G4TransportationManager.cc.

{
  delete fFieldManager; 
  delete fPropagatorInField;
  ClearNavigators(); 
  delete fGeomMessenger;
  delete fSafetyHelper;
}

Member Function Documentation

ActivateNavigator()

G4int G4TransportationManager::ActivateNavigator

(

G4Navigator *

aNavigator

)

Definition at line 286 of file G4TransportationManager.cc.

{
   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;
}

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

DeActivateNavigator()

void G4TransportationManager::DeActivateNavigator

(

G4Navigator *

aNavigator

)

Definition at line 321 of file G4TransportationManager.cc.

{
   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);
   }
}

Referenced by G4FastSimulationManagerProcess::EndTracking().

DeRegisterNavigator()

void G4TransportationManager::DeRegisterNavigator

(

G4Navigator *

aNavigator

)

Definition at line 247 of file G4TransportationManager.cc.

{
   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);
   }
}

GetActiveNavigatorsIterator()

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

GetFieldManager()

G4FieldManager * G4TransportationManager::GetFieldManager ( ) const

inline

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

GetNavigator() [1/2]

G4Navigator * G4TransportationManager::GetNavigator

(

const G4String &

worldName

)

Definition at line 171 of file G4TransportationManager.cc.

{
   // 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;
}

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 211 of file G4TransportationManager.cc.

{
   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;
}

GetNavigatorForTracking()

G4Navigator * G4TransportationManager::GetNavigatorForTracking ( ) const

inline

Referenced by G4RayTrajectory::AppendStep(), G4MultiNavigator::CheckMassWorld(), G4TheRayTracer::CreateBitMap(), G4TrajectoryDrawByOriginVolume::Draw(), G4PathFinder::EnableParallelNavigation(), G4ASCIITreeSceneHandler::EndModeling(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4CoupledTransportation::G4CoupledTransportation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4MultiNavigator::G4MultiNavigator(), G4SPSPosDistribution::G4SPSPosDistribution(), G4Transportation::G4Transportation(), GetParallelWorld(), G4SafetyHelper::InitialiseNavigator(), G4FastSimulationManager::ListTitle(), G4VTransitionRadiation::PostStepDoIt(), G4FastSimulationManagerProcess::StartTracking(), and G4CoupledTransportation::StartTracking().

GetNoActiveNavigators()

size_t G4TransportationManager::GetNoActiveNavigators ( ) const

inline

GetNoWorlds()

size_t G4TransportationManager::GetNoWorlds ( ) const

inline

Referenced by G4VisCommandSceneAddVolume::SetNewValue(), and G4PhysicalVolumeModel::Validate().

GetParallelWorld()

G4VPhysicalVolume * G4TransportationManager::GetParallelWorld

(

const G4String &

worldName

)

Definition at line 147 of file G4TransportationManager.cc.

{
   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;
}

Referenced by G4RunManager::ConstructScoringWorlds(), G4VUserParallelWorld::GetWorld(), G4ImportanceProcess::SetParallelWorld(), G4WeightCutOffProcess::SetParallelWorld(), G4WeightWindowProcess::SetParallelWorld(), G4ParallelWorldProcess::SetParallelWorld(), and G4ParallelWorldScoringProcess::SetParallelWorld().

GetPropagatorInField()

G4PropagatorInField * G4TransportationManager::GetPropagatorInField ( ) const

inline

Referenced by G4DecayWithSpin::DecayIt(), G4CoupledTransportation::G4CoupledTransportation(), G4ITTransportation::G4ITTransportation(), G4PathFinder::G4PathFinder(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4Transportation::G4Transportation(), and G4QSynchRad::GetRadius().

GetSafetyHelper()

G4SafetyHelper * G4TransportationManager::GetSafetyHelper ( ) const

inline

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

GetTransportationManager()

G4TransportationManager * G4TransportationManager::GetTransportationManager ( )

static

Definition at line 95 of file G4TransportationManager.cc.

{
   static G4TransportationManager theInstance;
   if (!fTransportationManager)
     fTransportationManager = &theInstance;
   
   return fTransportationManager;
}

Referenced by G4Scene::AddWorldIfEmpty(), G4RayTrajectory::AppendStep(), G4ErrorSurfaceTrajState::BuildErrorMatrix(), G4VPrimaryGenerator::CheckVertexInsideWorld(), G4RunManager::ConstructScoringWorlds(), G4TheRayTracer::CreateBitMap(), G4DecayWithSpin::DecayIt(), G4RunManagerKernel::DefineWorldVolume(), G4ITTransportation::DoesGlobalFieldExist(), G4TrajectoryDrawByOriginVolume::Draw(), G4DrawVoxels::DrawVoxels(), G4ASCIITreeSceneHandler::EndModeling(), G4CoupledTransportation::EndTracking(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4CoupledTransportation::G4CoupledTransportation(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4MultiNavigator::G4MultiNavigator(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PathFinder::G4PathFinder(), G4SPSPosDistribution::G4SPSPosDistribution(), G4SteppingManager::G4SteppingManager(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4Transportation::G4Transportation(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VisManager::GeometryHasChanged(), G4VMscModel::GetParticleChangeForMSC(), G4QSynchRad::GetRadius(), G4VUserParallelWorld::GetWorld(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4SafetyHelper::InitialiseNavigator(), G4ErrorRunManagerHelper::InitializeGeometry(), G4FastSimulationManager::ListTitle(), GFlashHitMaker::make(), G4OpBoundaryProcess::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4VMultipleScattering::PreparePhysicsTable(), G4ErrorFreeTrajState::PropagateError(), G4VisCommandSceneAddTrajectories::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4GlobalFastSimulationManager::ShowSetup(), G4FastSimulationManagerProcess::StartTracking(), G4CoupledTransportation::StartTracking(), and G4PhysicalVolumeModel::Validate().

GetWorldsIterator()

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

inline

Referenced by G4VisCommandSceneAddVolume::SetNewValue(), and G4PhysicalVolumeModel::Validate().

InactivateAll()

void G4TransportationManager::InactivateAll

(

)

Definition at line 352 of file G4TransportationManager.cc.

{
   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]);
}

Referenced by G4CoupledTransportation::EndTracking().

IsWorldExisting()

G4VPhysicalVolume * G4TransportationManager::IsWorldExisting

(

const G4String &

worldName

)

Definition at line 374 of file G4TransportationManager.cc.

{
   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;
}

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

SetFieldManager()

void G4TransportationManager::SetFieldManager

(

G4FieldManager *

newFieldManager

)

Definition at line 109 of file G4TransportationManager.cc.

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

SetNavigatorForTracking()

void G4TransportationManager::SetNavigatorForTracking ( G4Navigator *  newNavigator )

inline

SetPropagatorInField()

void G4TransportationManager::SetPropagatorInField ( G4PropagatorInField *  newFieldPropagator )

inline

SetWorldForTracking()

void G4TransportationManager::SetWorldForTracking ( G4VPhysicalVolume *  theWorld )

inline

Referenced by G4RunManagerKernel::DefineWorldVolume().

---

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

• G4TransportationManager.hh
• G4TransportationManager.cc