G4ITSafetyHelper Class Reference

#include <G4ITSafetyHelper.hh>

Inheritance diagram for G4ITSafetyHelper:

Classes
class	State

Public Member Functions
	G4ITSafetyHelper ()
	~G4ITSafetyHelper () override
G4double	CheckNextStep (const G4ThreeVector &position, const G4ThreeVector &direction, const G4double currentMaxStep, G4double &newSafety)
G4double	ComputeSafety (const G4ThreeVector &pGlobalPoint, G4double maxRadius=DBL_MAX)
void	Locate (const G4ThreeVector &pGlobalPoint, const G4ThreeVector &direction)
void	ReLocateWithinVolume (const G4ThreeVector &pGlobalPoint)
void	EnableParallelNavigation (G4bool parallel)
void	InitialiseNavigator ()
G4int	SetVerboseLevel (G4int lev)
G4VPhysicalVolume *	GetWorldVolume ()
void	SetCurrentSafety (G4double val, const G4ThreeVector &pos)
void	InitialiseHelper ()
Public Member Functions inherited from G4TrackStateDependent< G4ITSafetyHelper >
	~G4TrackStateDependent () override=default
virtual void	SetTrackState (G4shared_ptr< StateType > state)
G4VTrackStateHandle	PopTrackState () override
G4VTrackStateHandle	GetTrackState () const override
virtual StateTypeHandle	GetConcreteTrackState () const
void	LoadTrackState (G4TrackStateManager &manager) override
void	SaveTrackState (G4TrackStateManager &manager) override
void	NewTrackState () override
virtual StateTypeHandle	CreateTrackState () const
void	ResetTrackState () override
Public Member Functions inherited from G4VTrackStateDependent
	G4VTrackStateDependent ()=default
virtual	~G4VTrackStateDependent ()=default

Additional Inherited Members
Public Types inherited from G4TrackStateDependent< G4ITSafetyHelper >
using	ClassType
using	StateType
using	StateTypeHandle
Protected Member Functions inherited from G4TrackStateDependent< G4ITSafetyHelper >
	G4TrackStateDependent ()
Protected Attributes inherited from G4TrackStateDependent< G4ITSafetyHelper >
StateTypeHandle	fpTrackState

Detailed Description

Definition at line 54 of file G4ITSafetyHelper.hh.

Constructor & Destructor Documentation

G4ITSafetyHelper()

G4ITSafetyHelper::G4ITSafetyHelper

(

)

Definition at line 41 of file G4ITSafetyHelper.cc.

{
  fpPathFinder = nullptr; //  Cannot initialise this yet - a loop results
 
  // Initialization of the Navigator pointer is postponed, and must
  // be undertaken by another class calling InitialiseHelper()
  //
  fpMassNavigator = nullptr;
  fMassNavigatorId = -1;
}

~G4ITSafetyHelper()

G4ITSafetyHelper::~G4ITSafetyHelper ( )

overridedefault

Member Function Documentation

CheckNextStep()

G4double G4ITSafetyHelper::CheckNextStep	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		const G4double	currentMaxStep,
		G4double &	newSafety )

Definition at line 89 of file G4ITSafetyHelper.cc.

{
  // Distance in the Mass geometry
  //
  G4double linstep = fpMassNavigator->CheckNextStep(position, direction,
                                                    currentMaxStep, newSafety);
  fpTrackState->fLastSafetyPosition = position;
  fpTrackState->fLastSafety = newSafety;
 
  // TODO: Can replace this with a call to PathFinder
  //        giving id of Mass Geometry --> this avoid doing the work twice
 
  return linstep;
}

ComputeSafety()

G4double G4ITSafetyHelper::ComputeSafety	(	const G4ThreeVector &	pGlobalPoint,
		G4double	maxRadius = DBL_MAX )

Definition at line 107 of file G4ITSafetyHelper.cc.

{
  G4double newSafety;
 
  // Only recompute (calling Navigator/PathFinder) if 'position'
  // is  *not* the safety location and has moved 'significantly'
  //
  G4double moveLengthSq = (position - fpTrackState->fLastSafetyPosition).mag2();
  if ((moveLengthSq > 0.0))
  {
    if (!fUseParallelGeometries)
    {
      // Safety for mass geometry
      newSafety = fpMassNavigator->ComputeSafety(position, maxLength, true);
    }
    else
    {
      // Safety for all geometries
      newSafety = fpPathFinder->ComputeSafety(position);
    }
 
    // We can only store a 'true' safety - one that was not restricted by maxLength
    if (newSafety < maxLength)
    {
      fpTrackState->fLastSafety = newSafety;
      fpTrackState->fLastSafetyPosition = position;
    }
  }
  else
  {
    // return last value if position is not (significantly) changed
    //
    // G4double moveLength = 0;
    // if( moveLengthSq > 0.0 ) { moveLength= std::sqrt(moveLengthSq); }
    newSafety = fpTrackState->fLastSafety; // -moveLength;
  }
  return newSafety;
}

EnableParallelNavigation()

void G4ITSafetyHelper::EnableParallelNavigation ( G4bool parallel )

inline

GetWorldVolume()

G4VPhysicalVolume * G4ITSafetyHelper::GetWorldVolume ( )

inline

Definition at line 153 of file G4ITSafetyHelper.hh.

{
  return fpMassNavigator->GetWorldVolume();
}

InitialiseHelper()

void G4ITSafetyHelper::InitialiseHelper

(

)

Definition at line 76 of file G4ITSafetyHelper.cc.

{
  NewTrackState();
  if (fFirstCall)
  {
    InitialiseNavigator();
  }
  fFirstCall = false;
}

InitialiseNavigator()

void G4ITSafetyHelper::InitialiseNavigator

(

)

Definition at line 52 of file G4ITSafetyHelper.cc.

{
  fpPathFinder = G4PathFinder::GetInstance();
 
  G4ITTransportationManager* pTransportMgr =
      G4ITTransportationManager::GetTransportationManager();
 
  fpMassNavigator = pTransportMgr->GetNavigatorForTracking();
 
  if(fpMassNavigator == nullptr) abort();
 
  // Check
  //
  G4VPhysicalVolume* worldPV = fpMassNavigator->GetWorldVolume();
  if (worldPV == nullptr)
  {
    G4Exception("G4ITSafetyHelper::InitialiseNavigator",
                "InvalidNavigatorWorld", FatalException,
                "Found that existing tracking Navigator has NULL world");
  }
 
  // fMassNavigatorId = pTransportMgr->ActivateNavigator( fpMassNavigator );
}

Referenced by InitialiseHelper().

Locate()

void G4ITSafetyHelper::Locate	(	const G4ThreeVector &	pGlobalPoint,
		const G4ThreeVector &	direction )

Definition at line 179 of file G4ITSafetyHelper.cc.

{
  if (!fUseParallelGeometries)
  {
    fpMassNavigator->LocateGlobalPointAndSetup(newPosition, &newDirection, true,
                                               false);
  }
  else
  {
    fpPathFinder->Locate(newPosition, newDirection);
  }
}

ReLocateWithinVolume()

void G4ITSafetyHelper::ReLocateWithinVolume

(

const G4ThreeVector &

pGlobalPoint

)

Definition at line 147 of file G4ITSafetyHelper.cc.

{
#ifdef G4VERBOSE
  if (fVerbose > 0)
  {
    // There is an opportunity - and need - to check whether the proposed move is safe
    G4ThreeVector moveVec = newPosition - fpTrackState->fLastSafetyPosition;
    if (moveVec.mag2() > sqr(fpTrackState->fLastSafety))
    {
      // A problem exists - we are proposing to move outside 'Safety Sphere'
      G4ExceptionDescription ed;
      ed << " Safety Sphere:  Radius = " << fpTrackState->fLastSafety;
      ed << " Center   = " << fpTrackState->fLastSafetyPosition << G4endl;
      ed << " New Location :  Move   = " << moveVec.mag2();
      ed << " Position = " << newPosition << G4endl;
      G4Exception("G4ITSafetyHelper::ReLocateWithinVolume", "GeomNav999",
                  JustWarning,
                  "Unsafe Move> Asked to relocate beyond 'Safety sphere'.");
    }
  }
#endif
 
  if (!fUseParallelGeometries)
  {
    fpMassNavigator->LocateGlobalPointWithinVolume(newPosition);
  }
  else
  {
    fpPathFinder->ReLocate(newPosition);
  }
}

SetCurrentSafety()

void G4ITSafetyHelper::SetCurrentSafety ( G4double val, const G4ThreeVector & pos )

inline

Definition at line 159 of file G4ITSafetyHelper.hh.

{
  fpTrackState->fLastSafety = val;
  fpTrackState->fLastSafetyPosition = pos;
}

SetVerboseLevel()

G4int G4ITSafetyHelper::SetVerboseLevel ( G4int lev )

inline

Definition at line 97 of file G4ITSafetyHelper.hh.

  { G4int oldlv= fVerbose; fVerbose= lev; return oldlv;}

---

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

• G4ITSafetyHelper.hh
• G4ITSafetyHelper.cc