G4ITTransportationManager Class Reference

#include <G4ITTransportationManager.hh>

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

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

Private Member Functions
void	ClearNavigators ()
void	DeRegisterWorld (G4VPhysicalVolume *aWorld)
	G4ITTransportationManager ()
void	Initialize ()
	~G4ITTransportationManager ()

Private Attributes
std::vector< G4ITNavigator * >	fActiveNavigators
std::vector< G4ITNavigator * >	fNavigators
G4ITSafetyHelper *	fpSafetyHelper
std::vector< G4VPhysicalVolume * >	fWorlds

Static Private Attributes
static G4ThreadLocal G4ITTransportationManager *	fpInstance
	{Duplicated version of G4TransportationManager. This class just contains the pointer to the navigator object of the simulation.} More...

Detailed Description

Definition at line 61 of file G4ITTransportationManager.hh.

Constructor & Destructor Documentation

G4ITTransportationManager()

G4ITTransportationManager::G4ITTransportationManager ( )

private

Definition at line 45 of file G4ITTransportationManager.cc.

{
  Initialize();
}

References Initialize().

Referenced by GetTransportationManager().

~G4ITTransportationManager()

G4ITTransportationManager::~G4ITTransportationManager ( )

private

Definition at line 50 of file G4ITTransportationManager.cc.

{
  ClearNavigators();
  if (fpSafetyHelper) delete fpSafetyHelper;
}

References ClearNavigators(), and fpSafetyHelper.

Member Function Documentation

ActivateNavigator()

G4int G4ITTransportationManager::ActivateNavigator

(

G4ITNavigator *

aNavigator

)

Definition at line 267 of file G4ITTransportationManager.cc.

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

References fActiveNavigators, fNavigators, G4Exception(), and JustWarning.

ClearNavigators()

void G4ITTransportationManager::ClearNavigators ( )

private

Definition at line 71 of file G4ITTransportationManager.cc.

{
  std::vector<G4ITNavigator*>::iterator pNav;
  for (pNav = fNavigators.begin(); pNav != fNavigators.end(); pNav++)
  {
    delete *pNav;
  }
  fNavigators.clear();
  fActiveNavigators.clear();
  fWorlds.clear();
}

References fActiveNavigators, fNavigators, and fWorlds.

Referenced by ~G4ITTransportationManager().

DeActivateNavigator()

void G4ITTransportationManager::DeActivateNavigator

(

G4ITNavigator *

aNavigator

)

Definition at line 305 of file G4ITTransportationManager.cc.

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

References fActiveNavigators, fNavigators, G4Exception(), and JustWarning.

DeleteInstance()

void G4ITTransportationManager::DeleteInstance ( )

static

Definition at line 56 of file G4ITTransportationManager.cc.

{
  if (fpInstance)
  {
    delete fpInstance;
    fpInstance = 0;
  }
}

References fpInstance.

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!");
  }
  std::vector<G4ITNavigator*>::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("G4ITTransportationManager::DeRegisterNavigator()",
                "GeomNav1002", JustWarning, message);
  }
}

References DeRegisterWorld(), FatalException, fNavigators, G4Exception(), and JustWarning.

DeRegisterWorld()

void G4ITTransportationManager::DeRegisterWorld ( G4VPhysicalVolume *  aWorld )

private

Definition at line 406 of file G4ITTransportationManager.cc.

{
  std::vector<G4VPhysicalVolume*>::iterator pWorld = std::find(fWorlds.begin(),
                                                               fWorlds.end(),
                                                               aWorld);
  if (pWorld != fWorlds.end())
  {
    fWorlds.erase(pWorld);
  }
  else
  {
    G4String message = "World volume -" + aWorld->GetName()
                       + "- not found in memory!";
    G4Exception("G4ITTransportationManager::DeRegisterWorld()", "GeomNav1002",
                JustWarning, message);
  }
}

References fWorlds, G4Exception(), G4VPhysicalVolume::GetName(), and JustWarning.

Referenced by DeRegisterNavigator().

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 = 0;
  G4VPhysicalVolume* aWorld = IsWorldExisting(worldName);
  if (aWorld)
  {
    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;
}

References FatalException, fNavigators, G4Exception(), and IsWorldExisting().

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 = 0;
  std::vector<G4VPhysicalVolume*>::iterator 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;
}

References FatalException, fNavigators, fWorlds, G4Exception(), and G4VPhysicalVolume::GetName().

GetNavigatorForTracking()

G4ITNavigator * G4ITTransportationManager::GetNavigatorForTracking

(

)

const

Referenced by G4ITMultiNavigator::CheckMassWorld(), G4DNAMolecularDissociation::DecayIt(), G4ITMultiNavigator::G4ITMultiNavigator(), 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)
  {
    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;
}

References G4VPhysicalVolume::GetLogicalVolume(), GetNavigatorForTracking(), G4VPhysicalVolume::GetRotation(), G4LogicalVolume::GetSolid(), G4VPhysicalVolume::GetTranslation(), IsWorldExisting(), and RegisterWorld().

GetSafetyHelper()

G4ITSafetyHelper * G4ITTransportationManager::GetSafetyHelper ( ) const

inline

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

GetTransportationManager()

G4ITTransportationManager * G4ITTransportationManager::GetTransportationManager ( )

static

Definition at line 110 of file G4ITTransportationManager.cc.

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

References fpInstance, and G4ITTransportationManager().

Referenced by G4DNAMolecularDissociation::DecayIt(), G4ITMultiNavigator::G4ITMultiNavigator(), G4ITPathFinder::G4ITPathFinder(), 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]);
}

References fActiveNavigators, and fNavigators.

Initialize()

void G4ITTransportationManager::Initialize ( )

private

Definition at line 83 of file G4ITTransportationManager.cc.

{
  // Create the navigator for tracking and activate it; add to collections
  //
  G4ITNavigator* trackingNavigator = new G4ITNavigator();
  trackingNavigator->Activate(true);
  G4Navigator* navForTracking =
      G4TransportationManager::GetTransportationManager()
          ->GetNavigatorForTracking();
  G4VPhysicalVolume* world = navForTracking->GetWorldVolume();
  trackingNavigator->SetWorldVolume(world);
  fNavigators.push_back(trackingNavigator);
  fActiveNavigators.push_back(trackingNavigator);
  //fWorlds.push_back(world); // NULL registered
 
  size_t n_worlds = G4TransportationManager::GetTransportationManager()
      ->GetNoWorlds();
  std::vector<G4VPhysicalVolume*>::iterator it =
      G4TransportationManager::GetTransportationManager()->GetWorldsIterator();
 
  for (size_t i = 0; i < n_worlds; i++, it++)
  {
    fWorlds.push_back(*it);
  }
  fpSafetyHelper = new G4ITSafetyHelper();
}

References fActiveNavigators, fNavigators, fpSafetyHelper, fWorlds, G4TransportationManager::GetNavigatorForTracking(), G4TransportationManager::GetNoWorlds(), G4TransportationManager::GetTransportationManager(), G4TransportationManager::GetWorldsIterator(), and G4Navigator::GetWorldVolume().

Referenced by G4ITTransportationManager().

IsWorldExisting()

G4VPhysicalVolume * G4ITTransportationManager::IsWorldExisting

(

const G4String &

worldName

)

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

References fNavigators, fWorlds, and G4InuclParticleNames::name().

Referenced by GetNavigator(), and GetParallelWorld().

RegisterWorld()

G4bool G4ITTransportationManager::RegisterWorld

(

G4VPhysicalVolume *

aWorld

)

Definition at line 384 of file G4ITTransportationManager.cc.

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

References fWorlds.

Referenced by GetParallelWorld().

SetWorldForTracking()

void G4ITTransportationManager::SetWorldForTracking ( G4VPhysicalVolume *  theWorld )

inline

Field Documentation

fActiveNavigators

std::vector<G4ITNavigator*> G4ITTransportationManager::fActiveNavigators

private

Definition at line 122 of file G4ITTransportationManager.hh.

Referenced by ActivateNavigator(), ClearNavigators(), DeActivateNavigator(), InactivateAll(), and Initialize().

fNavigators

std::vector<G4ITNavigator*> G4ITTransportationManager::fNavigators

private

Definition at line 120 of file G4ITTransportationManager.hh.

Referenced by ActivateNavigator(), ClearNavigators(), DeActivateNavigator(), DeRegisterNavigator(), GetNavigator(), InactivateAll(), Initialize(), and IsWorldExisting().

fpInstance

G4ThreadLocal G4ITTransportationManager * G4ITTransportationManager::fpInstance

staticprivate

{Duplicated version of G4TransportationManager. This class just contains the pointer to the navigator object of the simulation.}

Definition at line 116 of file G4ITTransportationManager.hh.

Referenced by DeleteInstance(), and GetTransportationManager().

fpSafetyHelper

G4ITSafetyHelper* G4ITTransportationManager::fpSafetyHelper

private

Definition at line 119 of file G4ITTransportationManager.hh.

Referenced by Initialize(), and ~G4ITTransportationManager().

fWorlds

std::vector<G4VPhysicalVolume*> G4ITTransportationManager::fWorlds

private

Definition at line 124 of file G4ITTransportationManager.hh.

Referenced by ClearNavigators(), DeRegisterWorld(), GetNavigator(), Initialize(), IsWorldExisting(), and RegisterWorld().

---

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

• source/processes/electromagnetic/dna/management/include/G4ITTransportationManager.hh
• source/processes/electromagnetic/dna/management/src/G4ITTransportationManager.cc