G4TransportationManager Class Reference

G4TransportationManager is a singleton class which stores the navigator used by the transportation process to do the geometrical tracking. It also stores a pointer to the propagator used in a (magnetic) field and to the field manager. More...

#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)
std::vector< G4Navigator * >::iterator	GetActiveNavigatorsIterator ()
std::size_t	GetNoActiveNavigators () const
std::vector< G4VPhysicalVolume * >::iterator	GetWorldsIterator ()
std::size_t	GetNoWorlds () const
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)

Static Public Attributes
static constexpr G4int	kMassNavigatorId = 0

Detailed Description

G4TransportationManager is a singleton class which stores the navigator used by the transportation process to do the geometrical tracking. It also stores a pointer to the propagator used in a (magnetic) field and to the field manager.

Definition at line 60 of file G4TransportationManager.hh.

Constructor & Destructor Documentation

~G4TransportationManager()

G4TransportationManager::~G4TransportationManager

(

)

Destructor. Called internally only by G4RunManagerKernel.

Definition at line 96 of file G4TransportationManager.cc.

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

Member Function Documentation

ActivateNavigator()

G4int G4TransportationManager::ActivateNavigator

(

G4Navigator *

aNavigator

)

Definition at line 323 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(const auto & fActiveNavigator : fActiveNavigators)
   {
      if (fActiveNavigator == aNavigator)  { return id; }
      ++id;
   }
   
   fActiveNavigators.push_back(aNavigator);
   return id;
}

Referenced by G4FastSimulationManagerProcess::StartTracking().

ClearParallelWorlds()

void G4TransportationManager::ClearParallelWorlds

(

)

Clears collection of navigators and deletes the allocated objects associated with parallel worlds. Internal method, called only by the RunManager when the entire geometry is rebuilt from scratch.

Definition at line 469 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(nullptr); // NULL registered
}

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

DeActivateNavigator()

void G4TransportationManager::DeActivateNavigator

(

G4Navigator *

aNavigator

)

Definition at line 355 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);
   }
}

DeRegisterNavigator()

void G4TransportationManager::DeRegisterNavigator

(

G4Navigator *

aNavigator

)

Definition at line 285 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

Accessors for the active navigators.

Returns

An iterator to the list of active navigators.

Referenced by G4OpBoundaryProcess::PostStepDoIt().

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

Accessor and modifier for the tracking navigator. Retrieves/sets the first navigator pointer for the 'mass' geometry. It will be used as a template for cloning the tracking navigator of additional threads.

Definition at line 491 of file G4TransportationManager.cc.

{
  return fFirstTrackingNavigator;
}

GetInstanceIfExist()

G4TransportationManager * G4TransportationManager::GetInstanceIfExist ( )

static

Retrieve singleton instance pointer.

Definition at line 124 of file G4TransportationManager.cc.

{
   return fTransportationManager;
}

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

GetNavigator() [1/2]

G4Navigator * G4TransportationManager::GetNavigator

(

const G4String &

worldName

)

Returns a navigator associated to either the world volume name or associated to the pointer to the world physical volume. If not existing already, creates it and registers it in the collection.

Returns

Pointer to a tracking navigator.

Definition at line 209 of file G4TransportationManager.cc.

{
   // If already existing, return the stored pointer to the navigator
   //
   for (const auto & fNavigator : fNavigators)
   {
      if (fNavigator->GetWorldVolume()->GetName() == worldName)
      {
        return fNavigator;
      }
   }
 
   // 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 G4FastSimulationManagerProcess::StartTracking().

GetNavigator() [2/2]

G4Navigator * G4TransportationManager::GetNavigator

(

G4VPhysicalVolume *

aWorld

)

Definition at line 251 of file G4TransportationManager.cc.

{
   for (const auto & fNavigator : fNavigators)
   {
     if (fNavigator->GetWorldVolume() == aWorld) { return fNavigator; }
   }
   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

Accessor and modifier for the navigator for tracking.

Referenced by G4RayTrajectory::AppendStep(), G4AdjointPrimaryGenerator::ComputeAccumulatedDepthVectorAlongBackRay(), G4TheRayTracer::CreateBitMap(), G4VFieldModel::DescribeYourselfTo(), G4TrajectoryDrawByOriginVolume::Draw(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4Transportation::G4Transportation(), G4VisManager::G4VisSubThread(), G4XrayReflection::GetMeanFreePath(), GetParallelWorld(), G4SafetyHelper::InitialiseNavigator(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4MicroElecSurface::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4IStore::SetWorldVolume(), G4WeightWindowStore::SetWorldVolume(), and G4FastSimulationManagerProcess::StartTracking().

GetNoActiveNavigators()

std::size_t G4TransportationManager::GetNoActiveNavigators ( ) const

inline

GetNoWorlds()

std::size_t G4TransportationManager::GetNoWorlds ( ) const

inline

Referenced by G4RunManagerKernel::CheckRegions(), G4ToolsSGSceneHandler::EstablishBaseNodes(), G4TouchableUtils::FindTouchableProperties(), G4VisCommandSceneAddLocalAxes::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

GetParallelWorld()

G4VPhysicalVolume * G4TransportationManager::GetParallelWorld

(

const G4String &

worldName

)

Returns an exact copy of the tracking world volume. If already existing just returns the pointer.

Returns

Pointer to the tracking world volume.

Definition at line 185 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(), G4IStore::SetParallelWorldVolume(), and G4WeightWindowStore::SetParallelWorldVolume().

GetPropagatorInField()

G4PropagatorInField * G4TransportationManager::GetPropagatorInField ( ) const

inline

Accessors and modifiers for field handling.

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

GetSafetyHelper()

G4SafetyHelper * G4TransportationManager::GetSafetyHelper ( ) const

inline

Returns the pointer to the navigation safety helper instance.

Returns

Pointer to the navigation safety helper instance.

Referenced by G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess(), G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess(), G4NeutrinoElectronProcess::G4NeutrinoElectronProcess(), G4TauNeutrinoNucleusProcess::G4TauNeutrinoNucleusProcess(), G4Transportation::G4Transportation(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMscModel::GetParticleChangeForMSC(), and G4VMultipleScattering::PreparePhysicsTable().

GetTransportationManager()

G4TransportationManager * G4TransportationManager::GetTransportationManager ( )

static

Retrieve the static instance.

Definition at line 110 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(), G4SubEvtRunManager::ConstructScoringWorlds(), G4TaskRunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), G4TheRayTracer::CreateBitMap(), G4RunManagerKernel::DefineWorldVolume(), G4VFieldModel::DescribeYourselfTo(), G4ITTransportation::DoesGlobalFieldExist(), G4TrajectoryDrawByOriginVolume::Draw(), G4DrawVoxels::DrawVoxels(), G4CoupledTransportation::EndTracking(), G4ToolsSGSceneHandler::EstablishBaseNodes(), G4TrajectoryOriginVolumeFilter::Evaluate(), G4TouchableUtils::FindTouchableProperties(), G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GeometrySampler::G4GeometrySampler(), G4ImportanceConfigurator::G4ImportanceConfigurator(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ITTransportation::G4ITTransportation(), G4MultiNavigator::G4MultiNavigator(), G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess(), G4NeutrinoElectronProcess::G4NeutrinoElectronProcess(), G4ParallelGeometriesLimiterProcess::G4ParallelGeometriesLimiterProcess(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4SteppingManager::G4SteppingManager(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TauNeutrinoNucleusProcess::G4TauNeutrinoNucleusProcess(), G4Transportation::G4Transportation(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VisManager::G4VisSubThread(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VisManager::GeometryHasChanged(), G4XrayReflection::GetMeanFreePath(), G4VMscModel::GetParticleChangeForMSC(), G4VUserParallelWorld::GetWorld(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4TDNAOneStepThermalizationModel< MODEL >::Initialise(), G4SafetyHelper::InitialiseNavigator(), G4BOptnForceCommonTruncatedExp::Initialize(), G4ErrorRunManagerHelper::InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), G4FastSimulationManager::ListTitle(), G4FastSimHitMaker::make(), GFlashHitMaker::make(), G4MicroElecSurface::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4VTransitionRadiation::PostStepDoIt(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4VMultipleScattering::PreparePhysicsTable(), G4ErrorFreeTrajState::PropagateError(), G4RunManager::ReinitializeGeometry(), G4TrackingMessenger::SetNewValue(), G4VisCommandSceneAddLocalAxes::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4IStore::SetParallelWorldVolume(), G4WeightWindowStore::SetParallelWorldVolume(), G4RTPrimaryGeneratorAction::SetUp(), G4IStore::SetWorldVolume(), G4WeightWindowStore::SetWorldVolume(), G4GlobalFastSimulationManager::ShowSetup(), G4FastSimulationManagerProcess::StartTracking(), G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

GetWorldsIterator()

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

inline

Accessors for the registered worlds.

Returns

An iterator to the list of registered worlds.

Referenced by G4RunManagerKernel::CheckRegions(), G4MTRunManager::ConstructScoringWorlds(), G4SubEvtRunManager::ConstructScoringWorlds(), G4TaskRunManager::ConstructScoringWorlds(), G4ToolsSGSceneHandler::EstablishBaseNodes(), G4TouchableUtils::FindTouchableProperties(), G4VisCommandSceneAddLocalAxes::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

InactivateAll()

void G4TransportationManager::InactivateAll

(

)

Definition at line 385 of file G4TransportationManager.cc.

{
   for (const auto & fActiveNavigator : fActiveNavigators)
   {
      fActiveNavigator->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

)

Verifies existance or not of an istance of the world volume with same name in the collection.

Returns

Pointer to the tracking world volume.

Definition at line 406 of file G4TransportationManager.cc.

{
   auto pWorld = fWorlds.begin();
   if ( *pWorld==nullptr )  { *pWorld=fNavigators[0]->GetWorldVolume(); }
 
   for (const auto & fWorld : fWorlds)
   {
      if (fWorld->GetName() == name ) { return fWorld; }
   }
   return nullptr;
}

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

RegisterWorld()

G4bool G4TransportationManager::RegisterWorld

(

G4VPhysicalVolume *

aWorld

)

Methods for handling navigators. Navigator for tracking is always the first (i.e. position 0 in the collection) and cannot be de-registered.

Definition at line 425 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 134 of file G4TransportationManager.cc.

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

SetFirstTrackingNavigator()

void G4TransportationManager::SetFirstTrackingNavigator ( G4Navigator * nav )

static

Definition at line 501 of file G4TransportationManager.cc.

{
  fFirstTrackingNavigator= nav;
}

SetNavigatorForTracking()

void G4TransportationManager::SetNavigatorForTracking

(

G4Navigator *

newNavigator

)

Definition at line 154 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

Sets the world volume for tracking. This method is to be invoked by G4RunManagerKernel.

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

Member Data Documentation

kMassNavigatorId

G4int G4TransportationManager::kMassNavigatorId = 0

staticconstexpr

Navigator identifier. Accessed by G4CoupledTransportation.

Definition at line 171 of file G4TransportationManager.hh.

Referenced by G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), and G4CoupledTransportation::PostStepDoIt().

---

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

• G4TransportationManager.hh
• G4TransportationManager.cc