G4ITTransportationManager Class Reference

#include <G4ITTransportationManager.hh>

Public Member Functions
G4ITNavigator *	GetNavigatorForTracking () const
void	SetWorldForTracking (G4VPhysicalVolume *theWorld)
size_t	GetNoActiveNavigators () const
std::vector< G4ITNavigator * >::iterator	GetActiveNavigatorsIterator ()
size_t	GetNoWorlds () const
std::vector< G4VPhysicalVolume * >::iterator	GetWorldsIterator ()
G4ITSafetyHelper *	GetSafetyHelper () const
G4VPhysicalVolume *	GetParallelWorld (const G4String &worldName)
G4VPhysicalVolume *	IsWorldExisting (const G4String &worldName)
G4ITNavigator *	GetNavigator (const G4String &worldName)
G4ITNavigator *	GetNavigator (G4VPhysicalVolume *aWorld)
G4bool	RegisterWorld (G4VPhysicalVolume *aWorld)
void	DeRegisterNavigator (G4ITNavigator *aNavigator)
G4int	ActivateNavigator (G4ITNavigator *aNavigator)
void	DeActivateNavigator (G4ITNavigator *aNavigator)
void	InactivateAll ()

Static Public Member Functions
static void	DeleteInstance ()
static G4ITTransportationManager *	GetTransportationManager ()

Detailed Description

Definition at line 61 of file G4ITTransportationManager.hh.

Member Function Documentation

ActivateNavigator()

G4int G4ITTransportationManager::ActivateNavigator

(

G4ITNavigator *

aNavigator

)

Definition at line 267 of file G4ITTransportationManager.cc.

{
  auto 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("G4ITTransportationManager::ActivateNavigator()", "GeomNav1002",
                JustWarning, message);
    return -1;
  }
 
  aNavigator->Activate(true);
  G4int id = 0;
  std::vector<G4ITNavigator*>::iterator pActiveNav;
  for (pActiveNav = fActiveNavigators.begin();
      pActiveNav != fActiveNavigators.end(); pActiveNav++)
  {
    if (*pActiveNav == aNavigator)
    {
      return id;
    }
    id++;
  }
 
  fActiveNavigators.push_back(aNavigator);
  return id;
}

DeActivateNavigator()

void G4ITTransportationManager::DeActivateNavigator

(

G4ITNavigator *

aNavigator

)

Definition at line 305 of file G4ITTransportationManager.cc.

{
  auto 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("G4ITTransportationManager::DeActivateNavigator()",
                "GeomNav1002", JustWarning, message);
  }
 
  auto pActiveNav = std::find(
      fActiveNavigators.begin(), fActiveNavigators.end(), aNavigator);
  if (pActiveNav != fActiveNavigators.end())
  {
    fActiveNavigators.erase(pActiveNav);
  }
}

DeleteInstance()

void G4ITTransportationManager::DeleteInstance ( )

static

Definition at line 56 of file G4ITTransportationManager.cc.

{
  if (fpInstance != nullptr)
  {
    delete fpInstance;
    fpInstance = nullptr;
  }
}

DeRegisterNavigator()

void G4ITTransportationManager::DeRegisterNavigator

(

G4ITNavigator *

aNavigator

)

Definition at line 228 of file G4ITTransportationManager.cc.

{
  if (aNavigator == fNavigators[0])
  {
    G4Exception("G4ITTransportationManager::DeRegisterNavigator()",
                "GeomNav0003", FatalException,
                "The navigator for tracking CANNOT be deregistered!");
  }
  auto 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("G4ITTransportationManager::DeRegisterNavigator()",
                "GeomNav1002", JustWarning, message);
  }
}

GetActiveNavigatorsIterator()

std::vector< G4ITNavigator * >::iterator G4ITTransportationManager::GetActiveNavigatorsIterator ( )

inline

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

GetNavigator() [1/2]

G4ITNavigator * G4ITTransportationManager::GetNavigator

(

const G4String &

worldName

)

Definition at line 145 of file G4ITTransportationManager.cc.

{
  // If already existing, return the stored pointer to the navigator
  //
  std::vector<G4ITNavigator*>::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
  //
  G4ITNavigator* aNavigator = nullptr;
  G4VPhysicalVolume* aWorld = IsWorldExisting(worldName);
  if (aWorld != nullptr)
  {
    aNavigator = new G4ITNavigator();
    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("G4ITTransportationManager::GetNavigator(name)", "GeomNav0002",
                FatalException, message);
  }
 
  return aNavigator;
}

GetNavigator() [2/2]

G4ITNavigator * G4ITTransportationManager::GetNavigator

(

G4VPhysicalVolume *

aWorld

)

Definition at line 188 of file G4ITTransportationManager.cc.

{
  std::vector<G4ITNavigator*>::iterator pNav;
  for (pNav = fNavigators.begin(); pNav != fNavigators.end(); pNav++)
  {
    if ((*pNav)->GetWorldVolume() == aWorld)
    {
      return *pNav;
    }
  }
  G4ITNavigator* aNavigator = nullptr;
  auto pWorld = std::find(fWorlds.begin(),
                                                               fWorlds.end(),
                                                               aWorld);
  if (pWorld != fWorlds.end())
  {
    aNavigator = new G4ITNavigator();
    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("G4ITTransportationManager::GetNavigator(pointer)",
                "GeomNav0002", FatalException, message);
  }
 
  return aNavigator;
}

GetNavigatorForTracking()

G4ITNavigator * G4ITTransportationManager::GetNavigatorForTracking

(

)

const

Referenced by G4ITMultiNavigator::CheckMassWorld(), G4DNAMolecularDissociation::DecayIt(), G4ITMultiNavigator::G4ITMultiNavigator(), G4ITTransportation::G4ITTransportation(), G4ITTransportation::G4ITTransportation(), GetParallelWorld(), and G4ITSafetyHelper::InitialiseNavigator().

GetNoActiveNavigators()

size_t G4ITTransportationManager::GetNoActiveNavigators ( ) const

inline

GetNoWorlds()

size_t G4ITTransportationManager::GetNoWorlds ( ) const

inline

GetParallelWorld()

G4VPhysicalVolume * G4ITTransportationManager::GetParallelWorld

(

const G4String &

worldName

)

Definition at line 123 of file G4ITTransportationManager.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;
}

GetSafetyHelper()

G4ITSafetyHelper * G4ITTransportationManager::GetSafetyHelper ( ) const

inline

Referenced by G4ITPathFinder::EnableParallelNavigation(), G4ITTransportation::G4ITTransportation(), G4ITTransportation::G4ITTransportation(), and G4ITPathFinder::PrepareNewTrack().

GetTransportationManager()

G4ITTransportationManager * G4ITTransportationManager::GetTransportationManager ( )

static

Definition at line 110 of file G4ITTransportationManager.cc.

{
  if (fpInstance == nullptr) fpInstance = new G4ITTransportationManager;
  return fpInstance;
}

Referenced by G4DNAMolecularDissociation::DecayIt(), G4ITMultiNavigator::G4ITMultiNavigator(), G4ITPathFinder::G4ITPathFinder(), G4ITTransportation::G4ITTransportation(), G4ITTransportation::G4ITTransportation(), G4ITSafetyHelper::InitialiseNavigator(), and G4ITStepProcessor::Initialize().

GetWorldsIterator()

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

inline

InactivateAll()

void G4ITTransportationManager::InactivateAll

(

)

Definition at line 336 of file G4ITTransportationManager.cc.

{
  std::vector<G4ITNavigator*>::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]);
}

IsWorldExisting()

G4VPhysicalVolume * G4ITTransportationManager::IsWorldExisting

(

const G4String &

worldName

)

Definition at line 359 of file G4ITTransportationManager.cc.

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

Referenced by GetNavigator(), and GetParallelWorld().

RegisterWorld()

G4bool G4ITTransportationManager::RegisterWorld

(

G4VPhysicalVolume *

aWorld

)

Definition at line 384 of file G4ITTransportationManager.cc.

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

Referenced by GetParallelWorld().

SetWorldForTracking()

void G4ITTransportationManager::SetWorldForTracking ( G4VPhysicalVolume * theWorld )

inline

---

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

• G4ITTransportationManager.hh
• G4ITTransportationManager.cc