G4ITTransportationManager Class Reference

#include <G4ITTransportationManager.hh>

Collaboration diagram for G4ITTransportationManager:

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

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

Private Attributes
G4ITSafetyHelper *	fpSafetyHelper
std::vector< G4ITNavigator * >	fNavigators
std::vector< G4ITNavigator * >	fActiveNavigators
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 62 of file G4ITTransportationManager.hh.

Constructor & Destructor Documentation

G4ITTransportationManager()

G4ITTransportationManager::G4ITTransportationManager ( )

private

Definition at line 46 of file G4ITTransportationManager.cc.

{
  Initialize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

~G4ITTransportationManager()

G4ITTransportationManager::~G4ITTransportationManager ( )

private

Definition at line 51 of file G4ITTransportationManager.cc.

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

Here is the call graph for this function:

Member Function Documentation

ActivateNavigator()

G4int G4ITTransportationManager::ActivateNavigator

(

G4ITNavigator *

aNavigator

)

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

Here is the call graph for this function:

ClearNavigators()

void G4ITTransportationManager::ClearNavigators ( )

private

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

Here is the caller graph for this function:

DeActivateNavigator()

void G4ITTransportationManager::DeActivateNavigator

(

G4ITNavigator *

aNavigator

)

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

Here is the call graph for this function:

DeleteInstance()

void G4ITTransportationManager::DeleteInstance ( )

static

Definition at line 57 of file G4ITTransportationManager.cc.

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

DeRegisterNavigator()

void G4ITTransportationManager::DeRegisterNavigator

(

G4ITNavigator *

aNavigator

)

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

Here is the call graph for this function:

DeRegisterWorld()

void G4ITTransportationManager::DeRegisterWorld ( G4VPhysicalVolume *  aWorld )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetActiveNavigatorsIterator()

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

inline

Here is the caller graph for this function:

GetNavigator() [1/2]

G4ITNavigator * G4ITTransportationManager::GetNavigator

(

const G4String &

worldName

)

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

Here is the call graph for this function:

GetNavigator() [2/2]

G4ITNavigator * G4ITTransportationManager::GetNavigator

(

G4VPhysicalVolume *

aWorld

)

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

Here is the call graph for this function:

GetNavigatorForTracking()

G4ITNavigator* G4ITTransportationManager::GetNavigatorForTracking

(

)

const

Here is the caller graph for this function:

GetNoActiveNavigators()

size_t G4ITTransportationManager::GetNoActiveNavigators ( ) const

inline

GetNoWorlds()

size_t G4ITTransportationManager::GetNoWorlds ( ) const

inline

GetParallelWorld()

G4VPhysicalVolume * G4ITTransportationManager::GetParallelWorld

(

const G4String &

worldName

)

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

Here is the call graph for this function:

GetSafetyHelper()

G4ITSafetyHelper* G4ITTransportationManager::GetSafetyHelper ( ) const

inline

Here is the caller graph for this function:

GetTransportationManager()

G4ITTransportationManager * G4ITTransportationManager::GetTransportationManager ( )

static

Definition at line 111 of file G4ITTransportationManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GetWorldsIterator()

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

inline

InactivateAll()

void G4ITTransportationManager::InactivateAll

(

)

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

Initialize()

void G4ITTransportationManager::Initialize ( )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

IsWorldExisting()

G4VPhysicalVolume * G4ITTransportationManager::IsWorldExisting

(

const G4String &

worldName

)

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

Here is the caller graph for this function:

RegisterWorld()

G4bool G4ITTransportationManager::RegisterWorld

(

G4VPhysicalVolume *

aWorld

)

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

Here is the caller graph for this function:

SetWorldForTracking()

void G4ITTransportationManager::SetWorldForTracking ( G4VPhysicalVolume *  theWorld )

inline

Member Data Documentation

fActiveNavigators

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

private

Definition at line 123 of file G4ITTransportationManager.hh.

fNavigators

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

private

Definition at line 121 of file G4ITTransportationManager.hh.

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 117 of file G4ITTransportationManager.hh.

fpSafetyHelper

G4ITSafetyHelper* G4ITTransportationManager::fpSafetyHelper

private

Definition at line 120 of file G4ITTransportationManager.hh.

fWorlds

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

private

Definition at line 125 of file G4ITTransportationManager.hh.

---

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

• G4ITTransportationManager.hh
• G4ITTransportationManager.cc