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 (  )  [protected]

Definition at line 55 of file G4TransportationManager.cc.

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

00056 { 
00057   if (fTransportationManager)
00058   {
00059     G4Exception("G4TransportationManager::G4TransportationManager()",
00060                 "GeomNav0002", FatalException,
00061                 "Only ONE instance of G4TransportationManager is allowed!");
00062   }
00063 
00064   // Create the navigator for tracking and activate it; add to collections
00065   //
00066   G4Navigator* trackingNavigator = new G4Navigator();
00067   trackingNavigator->Activate(true);
00068   fNavigators.push_back(trackingNavigator);
00069   fActiveNavigators.push_back(trackingNavigator);
00070   fWorlds.push_back(trackingNavigator->GetWorldVolume()); // NULL registered
00071 
00072   fGeomMessenger    = new G4GeometryMessenger(this);
00073   fFieldManager     = new G4FieldManager();
00074   fPropagatorInField= new G4PropagatorInField(trackingNavigator,fFieldManager);
00075   fSafetyHelper     = new G4SafetyHelper();
00076 }

G4TransportationManager::~G4TransportationManager (  )  [protected]

Definition at line 81 of file G4TransportationManager.cc.

00082 {
00083   delete fFieldManager; 
00084   delete fPropagatorInField;
00085   ClearNavigators(); 
00086   delete fGeomMessenger;
00087   delete fSafetyHelper;
00088 }

Member Function Documentation

G4int G4TransportationManager::ActivateNavigator ( G4Navigator *  aNavigator  ) 

Definition at line 286 of file G4TransportationManager.cc.

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

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

00287 {
00288    std::vector<G4Navigator*>::iterator pNav =
00289      std::find(fNavigators.begin(), fNavigators.end(), aNavigator);
00290    if (pNav == fNavigators.end())
00291    {
00292       G4String message
00293          = "Navigator for volume -" + aNavigator->GetWorldVolume()->GetName()
00294          + "- not found in memory!";      
00295       G4Exception("G4TransportationManager::ActivateNavigator()",
00296                   "GeomNav1002", JustWarning, message);
00297       return -1;
00298    }
00299 
00300    aNavigator->Activate(true);
00301    G4int id = 0;
00302    std::vector<G4Navigator*>::iterator pActiveNav;
00303    for(pActiveNav=fActiveNavigators.begin();
00304        pActiveNav!=fActiveNavigators.end(); pActiveNav++)
00305    {
00306       if (*pActiveNav == aNavigator)  { return id; }
00307       id++;
00308    }
00309    
00310    fActiveNavigators.push_back(aNavigator);
00311    return id;
00312 }

void G4TransportationManager::DeActivateNavigator ( G4Navigator *  aNavigator  ) 

Definition at line 321 of file G4TransportationManager.cc.

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

Referenced by G4FastSimulationManagerProcess::EndTracking().

00322 {
00323    std::vector<G4Navigator*>::iterator pNav =
00324      std::find(fNavigators.begin(), fNavigators.end(), aNavigator);
00325    if (pNav != fNavigators.end())
00326    {
00327       (*pNav)->Activate(false);
00328    }
00329    else
00330    {
00331       G4String message
00332          = "Navigator for volume -" + aNavigator->GetWorldVolume()->GetName()
00333          + "- not found in memory!";
00334       G4Exception("G4TransportationManager::DeActivateNavigator()",
00335                   "GeomNav1002", JustWarning, message);
00336    }
00337 
00338    std::vector<G4Navigator*>::iterator pActiveNav =
00339      std::find(fActiveNavigators.begin(), fActiveNavigators.end(), aNavigator);
00340    if (pActiveNav != fActiveNavigators.end())
00341    {
00342       fActiveNavigators.erase(pActiveNav);
00343    }
00344 }

void G4TransportationManager::DeRegisterNavigator ( G4Navigator *  aNavigator  ) 

Definition at line 247 of file G4TransportationManager.cc.

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

00248 {
00249    if (aNavigator == fNavigators[0])
00250    {
00251       G4Exception("G4TransportationManager::DeRegisterNavigator()",
00252                   "GeomNav0003", FatalException,
00253                   "The navigator for tracking CANNOT be deregistered!");
00254    }
00255    std::vector<G4Navigator*>::iterator pNav =
00256      std::find(fNavigators.begin(), fNavigators.end(), aNavigator);
00257    if (pNav != fNavigators.end())
00258    {
00259       // Deregister associated world volume
00260       //
00261       DeRegisterWorld((*pNav)->GetWorldVolume());
00262 
00263       // Deregister the navigator
00264       //
00265       fNavigators.erase(pNav);
00266    }
00267    else
00268    {
00269       G4String message
00270          = "Navigator for volume -" + aNavigator->GetWorldVolume()->GetName()
00271          + "- not found in memory!";      
00272       G4Exception("G4TransportationManager::DeRegisterNavigator()",
00273                   "GeomNav1002", JustWarning, message);
00274    }
00275 }

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

Definition at line 126 of file G4TransportationManager.icc.

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

00127 {
00128    std::vector<G4Navigator*>::iterator iterator
00129      = std::vector<G4Navigator*>::iterator(fActiveNavigators.begin());
00130    return iterator;
00131 }

G4FieldManager * G4TransportationManager::GetFieldManager (  )  const [inline]

Definition at line 103 of file G4TransportationManager.icc.

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

00104 {
00105    return fFieldManager;
00106 }

G4Navigator * G4TransportationManager::GetNavigator ( G4VPhysicalVolume *  aWorld  ) 

Definition at line 211 of file G4TransportationManager.cc.

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

00212 {
00213    std::vector<G4Navigator*>::iterator pNav;
00214    for (pNav=fNavigators.begin(); pNav!=fNavigators.end(); pNav++)
00215    {
00216      if ((*pNav)->GetWorldVolume() == aWorld) { return *pNav; }
00217    }
00218    G4Navigator* aNavigator = 0;
00219    std::vector<G4VPhysicalVolume*>::iterator pWorld =
00220      std::find(fWorlds.begin(), fWorlds.end(), aWorld);
00221    if (pWorld != fWorlds.end())
00222    {
00223       aNavigator = new G4Navigator();
00224       aNavigator->SetWorldVolume(aWorld);
00225       fNavigators.push_back(aNavigator);
00226    }
00227    else
00228    {
00229       G4String message
00230          = "World volume with name -" + aWorld->GetName()
00231          + "- does not exist. Create it first by GetParallelWorld() method!";
00232       G4Exception("G4TransportationManager::GetNavigator(pointer)",
00233                   "GeomNav0002", FatalException, message);
00234    }
00235 
00236    return aNavigator;
00237 }

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

Definition at line 171 of file G4TransportationManager.cc.

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

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

00172 {
00173    // If already existing, return the stored pointer to the navigator
00174    //
00175    std::vector<G4Navigator*>::iterator pNav;
00176    for (pNav=fNavigators.begin(); pNav!=fNavigators.end(); pNav++)
00177    {
00178       if ((*pNav)->GetWorldVolume()->GetName() == worldName) { return *pNav; }
00179    }
00180 
00181    // Check if world of that name already exists,
00182    // create a navigator and register it
00183    //
00184    G4Navigator* aNavigator = 0;
00185    G4VPhysicalVolume* aWorld = IsWorldExisting(worldName);
00186    if(aWorld)
00187    {
00188       aNavigator = new G4Navigator();
00189       aNavigator->SetWorldVolume(aWorld);
00190       fNavigators.push_back(aNavigator);
00191    }
00192    else
00193    {
00194       G4String message
00195          = "World volume with name -" + worldName
00196          + "- does not exist. Create it first by GetParallelWorld() method!";      
00197       G4Exception("G4TransportationManager::GetNavigator(name)",
00198                   "GeomNav0002", FatalException, message);
00199    }
00200 
00201    return aNavigator;
00202 }

G4Navigator * G4TransportationManager::GetNavigatorForTracking (  )  const [inline]

Definition at line 44 of file G4TransportationManager.icc.

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

00045 {
00046    return fNavigators[0];
00047 }

size_t G4TransportationManager::GetNoActiveNavigators (  )  const [inline]

Definition at line 114 of file G4TransportationManager.icc.

00115 {
00116    return fActiveNavigators.size();
00117 }

size_t G4TransportationManager::GetNoWorlds (  )  const [inline]

Definition at line 139 of file G4TransportationManager.icc.

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

00140 {
00141    return fWorlds.size();
00142 }

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

Definition at line 147 of file G4TransportationManager.cc.

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

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

00148 {
00149    G4VPhysicalVolume* wPV = IsWorldExisting(worldName);
00150    if (!wPV)
00151    {
00152      wPV = GetNavigatorForTracking()->GetWorldVolume();
00153      G4LogicalVolume* wLV = wPV->GetLogicalVolume();
00154      wLV = new G4LogicalVolume(wLV->GetSolid(), 0,
00155                                worldName);
00156      wPV = new G4PVPlacement (wPV->GetRotation(),
00157                               wPV->GetTranslation(),
00158                               wLV, worldName, 0, false, 0);
00159      RegisterWorld(wPV);
00160    }
00161    return wPV;
00162 }

G4PropagatorInField * G4TransportationManager::GetPropagatorInField (  )  const [inline]

Definition at line 80 of file G4TransportationManager.icc.

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

00081 {
00082    return fPropagatorInField;
00083 }

G4SafetyHelper * G4TransportationManager::GetSafetyHelper (  )  const [inline]

Definition at line 164 of file G4TransportationManager.icc.

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

00165 {
00166   return fSafetyHelper;
00167 }

G4TransportationManager * G4TransportationManager::GetTransportationManager (  )  [static]

Definition at line 95 of file G4TransportationManager.cc.

Referenced by G4Scene::AddWorldIfEmpty(), G4RayTrajectory::AppendStep(), G4ErrorSurfaceTrajState::BuildErrorMatrix(), G4VPrimaryGenerator::CheckVertexInsideWorld(), G4RunManager::ConstructScoringWorlds(), G4TheRayTracer::CreateBitMap(), G4DecayWithSpin::DecayIt(), G4RunManagerKernel::DefineWorldVolume(), G4Transportation::DoesGlobalFieldExist(), G4ITTransportation::DoesGlobalFieldExist(), G4CoupledTransportation::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(), G4VTransitionRadiation::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4VMultipleScattering::PreparePhysicsTable(), G4ErrorFreeTrajState::PropagateError(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSceneAddTrajectories::SetNewValue(), G4GlobalFastSimulationManager::ShowSetup(), G4FastSimulationManagerProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4PhysicalVolumeModel::Validate(), and G4GDMLParser::Write().

00096 {
00097    static G4TransportationManager theInstance;
00098    if (!fTransportationManager)
00099      fTransportationManager = &theInstance;
00100    
00101    return fTransportationManager;
00102 }

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

Definition at line 151 of file G4TransportationManager.icc.

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

00152 {
00153    std::vector<G4VPhysicalVolume*>::iterator iterator
00154      = std::vector<G4VPhysicalVolume*>::iterator(fWorlds.begin());
00155    return iterator;
00156 }

void G4TransportationManager::InactivateAll (  ) 

Definition at line 352 of file G4TransportationManager.cc.

Referenced by G4CoupledTransportation::EndTracking().

00353 {
00354    std::vector<G4Navigator*>::iterator pNav;
00355    for (pNav=fActiveNavigators.begin(); pNav!=fActiveNavigators.end(); pNav++)
00356    {
00357       (*pNav)->Activate(false);
00358    }
00359    fActiveNavigators.clear();
00360 
00361    // Restore status for the navigator for tracking
00362    //
00363    fNavigators[0]->Activate(true);
00364    fActiveNavigators.push_back(fNavigators[0]);
00365 }

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

Definition at line 374 of file G4TransportationManager.cc.

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

00375 {
00376    std::vector<G4VPhysicalVolume*>::iterator pWorld = fWorlds.begin();
00377    if (*pWorld==0)  { *pWorld=fNavigators[0]->GetWorldVolume(); }
00378 
00379    for (pWorld=fWorlds.begin(); pWorld!=fWorlds.end(); pWorld++)
00380    {
00381       if ((*pWorld)->GetName() == name ) { return *pWorld; }
00382    }
00383    return 0;
00384 }

void G4TransportationManager::SetFieldManager ( G4FieldManager *  newFieldManager  ) 

Definition at line 109 of file G4TransportationManager.cc.

00110 {
00111    fFieldManager = newFieldManager; 
00112 
00113    // Message the PropagatorInField, 
00114    // which also maintains this information (to be reviewed)
00115    //
00116    if( fPropagatorInField )
00117    {
00118       fPropagatorInField -> SetDetectorFieldManager( newFieldManager );
00119    }
00120 }

void G4TransportationManager::SetNavigatorForTracking ( G4Navigator *  newNavigator  )  [inline]

Definition at line 69 of file G4TransportationManager.icc.

00070 {
00071    fNavigators[0] = newNavigator;
00072 }

void G4TransportationManager::SetPropagatorInField ( G4PropagatorInField *  newFieldPropagator  )  [inline]

Definition at line 92 of file G4TransportationManager.icc.

00093 {
00094    fPropagatorInField = newFieldPropagator;
00095 }

void G4TransportationManager::SetWorldForTracking ( G4VPhysicalVolume *  theWorld  )  [inline]

Definition at line 56 of file G4TransportationManager.icc.

Referenced by G4RunManagerKernel::DefineWorldVolume().

00057 {
00058    fWorlds[0] = theWorld;
00059    fNavigators[0]->SetWorldVolume(theWorld);
00060 }

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:34 2013 for Geant4 by  doxygen 1.4.7