G4SafetyCalculator Class Reference

G4SafetyCalculator is a class that provides an estimate of the isotropic safety (the minimum distance from a global point to the nearest boundary of the current volume or the nearest daughter volumes). More...

#include <G4SafetyCalculator.hh>

Public Member Functions
	G4SafetyCalculator (const G4Navigator &navigator, const G4NavigationHistory &navHistory)
	G4SafetyCalculator (const G4SafetyCalculator &)=delete
G4SafetyCalculator &	operator= (const G4SafetyCalculator &)=delete
	~G4SafetyCalculator ()=default
G4double	SafetyInCurrentVolume (const G4ThreeVector &globalpoint, G4VPhysicalVolume *physicalVolume, const G4double pProposedMaxLength=DBL_MAX, G4bool verbose=false)
G4VExternalNavigation *	GetExternalNavigation () const
void	SetExternalNavigation (G4VExternalNavigation *externalNav)
void	CompareSafetyValues (G4double oldSafety, G4double newValue, G4VPhysicalVolume *motherPhysical, const G4ThreeVector &globalPoint, G4bool keepState, G4double maxLength, G4bool enteredVolume, G4bool exitedVolume)

Protected Member Functions
void	QuickLocateWithinVolume (const G4ThreeVector &pointLocal, G4VPhysicalVolume *motherPhysical)
G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &rGlobPoint) const
G4ThreeVector	ComputeLocalAxis (const G4ThreeVector &pVec) const
EVolume	CharacteriseDaughters (const G4LogicalVolume *pLog) const
G4int	GetDaughtersRegularStructureId (const G4LogicalVolume *pLv) const

Detailed Description

G4SafetyCalculator is a class that provides an estimate of the isotropic safety (the minimum distance from a global point to the nearest boundary of the current volume or the nearest daughter volumes).

Definition at line 72 of file G4SafetyCalculator.hh.

Constructor & Destructor Documentation

G4SafetyCalculator() [1/2]

G4SafetyCalculator::G4SafetyCalculator	(	const G4Navigator &	navigator,
		const G4NavigationHistory &	navHistory )

Constructor, initialisers and setup.

Definition at line 36 of file G4SafetyCalculator.cc.

  : fNavigator(navigator), fNavHistory(navHistory)
{
  fkCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();   
}

Referenced by G4SafetyCalculator(), and operator=().

G4SafetyCalculator() [2/2]

G4SafetyCalculator::G4SafetyCalculator ( const G4SafetyCalculator & )

delete

Copy constructor & assignment operator not allowed.

~G4SafetyCalculator()

G4SafetyCalculator::~G4SafetyCalculator ( )

default

Destructor. No actions.

Member Function Documentation

CharacteriseDaughters()

EVolume G4SafetyCalculator::CharacteriseDaughters ( const G4LogicalVolume * pLog ) const

inlineprotected

Characterises the daughter of logical volume.

Referenced by QuickLocateWithinVolume(), and SafetyInCurrentVolume().

CompareSafetyValues()

void G4SafetyCalculator::CompareSafetyValues	(	G4double	oldSafety,
		G4double	newValue,
		G4VPhysicalVolume *	motherPhysical,
		const G4ThreeVector &	globalPoint,
		G4bool	keepState,
		G4double	maxLength,
		G4bool	enteredVolume,
		G4bool	exitedVolume )

Compares estimates of the safety, and reports if found difference(s).

Definition at line 210 of file G4SafetyCalculator.cc.

{
  constexpr G4double reportThreshold= 3.0e-14;
    // At least warn if rel-error exceeds it
  constexpr G4double  errorThreshold= 1.0e-08;
    // Fatal if relative error is larger
  constexpr G4double epsilonLen= 1.0e-20;
    // Baseline minimal value for divisor
 
  const G4double oldSafetyPlus = std::fabs(oldSafety)+epsilonLen;
  if( std::fabs( newValue - oldSafety) > reportThreshold * oldSafetyPlus )
  {
    G4ExceptionSeverity severity= FatalException;
    std::ostringstream msg;
    G4double diff= (newValue-oldSafety);
    G4double relativeDiff= diff / oldSafetyPlus;
 
    msg << " New (G4SafetyCalculator) value *disagrees* by relative diff " << relativeDiff
        << " in physical volume '" << motherPhysical->GetName() << "' "
        << "copy-no = " << motherPhysical->GetCopyNo();
    if( enteredDaughterVol ) { msg << "  ( Just Entered new daughter volume. ) "; }
    if( exitedMotherVol )    { msg << "  ( Just Exited previous volume. ) "; }
    msg << G4endl;
    msg << " Safeties:   old= "  << std::setprecision(12) << oldSafety
        << "   trial " << newValue
        << "  new-old= " << std::setprecision(7) << diff <<  G4endl;
 
    if( std::fabs(diff) < errorThreshold * ( std::fabs(oldSafety)+1.0e-20 ) )
    {
      msg << " (tiny difference) ";
      severity= JustWarning;
    }
    else
    {
      msg << " (real difference) ";
      severity= FatalException;
 
      // Extra information -- for big errors
      msg << " NOTE:  keepState =  " << keepState << G4endl;
      msg << " Location -  Global coordinates: " << globalPoint
          << "  volume= '" << motherPhysical->GetName() << "'"
          << " copy-no= " << motherPhysical->GetCopyNo() << G4endl;
      msg << " Argument maxLength= " << maxLength << G4endl;
 
      std::size_t depth= fNavHistory.GetDepth();
      msg << " Navigation History: depth = " << depth << G4endl;
      for( G4int i=1; i<(G4int)depth; ++i )
      {
         msg << "     d= " << i << " " << std::setw(32)
             << fNavHistory.GetVolume(i)->GetName()
             << "  copyNo= " << fNavHistory.GetReplicaNo(i);
         msg << G4endl;
      }
    }
 
#ifdef G4DEBUG_NAVIGATION
    G4double redo= SafetyInCurrentVolume(globalPoint, motherPhysical,
                                         maxLength, true);
    msg << " Redoing estimator: value = " << std::setprecision(16) << redo
        << "  diff/last= " << std::setprecision(7) << redo - newValue
        << "  diff/old= " << redo - oldSafety << G4endl;
#endif
 
    G4Exception("G4SafetyCalculator::CompareSafetyValues()", "GeomNav1007",
                severity, msg);
  }
}

ComputeLocalAxis()

G4ThreeVector G4SafetyCalculator::ComputeLocalAxis ( const G4ThreeVector & pVec ) const

inlineprotected

Computes the local direction of the specified vector in the reference system of the volume that was found by LocateGlobalPointAndSetup().

Parameters

[in]

pVec

Vector in global coordinates.

Returns

The local direction of the specified vector in global coordinates.

ComputeLocalPoint()

G4ThreeVector G4SafetyCalculator::ComputeLocalPoint ( const G4ThreeVector & rGlobPoint ) const

inlineprotected

Computes point in local coordinates system, given a position vector in world coordinate system.

Parameters

[in]

rGlobPoint

Point in global coordinates.

Returns

The point in local coordinates system.

Referenced by SafetyInCurrentVolume().

GetDaughtersRegularStructureId()

G4int G4SafetyCalculator::GetDaughtersRegularStructureId ( const G4LogicalVolume * pLv ) const

inlineprotected

Gets regular structure ID of first daughter.

Referenced by QuickLocateWithinVolume(), and SafetyInCurrentVolume().

GetExternalNavigation()

G4VExternalNavigation * G4SafetyCalculator::GetExternalNavigation

(

)

const

Accessor & modifier for custom external navigation.

Definition at line 194 of file G4SafetyCalculator.cc.

{
  return fpExternalNav;   
}

operator=()

G4SafetyCalculator & G4SafetyCalculator::operator= ( const G4SafetyCalculator & )

delete

QuickLocateWithinVolume()

void G4SafetyCalculator::QuickLocateWithinVolume ( const G4ThreeVector & pointLocal, G4VPhysicalVolume * motherPhysical )

protected

Prepare state of sub-navigators by informing them of current point.

Parameters

[in]	pointLocal	Point in local coordinates.
[in]	motherPhysical	Pointer to current volume where to relocate in case an external custom navigator is used.

Definition at line 152 of file G4SafetyCalculator.cc.

{
  // For the case of Voxel (or Parameterised) volume the respective 
  // sub-navigator must be messaged to update its voxel information etc
 
  // Update the state of the Sub Navigators 
  // - in particular any voxel information they store/cache
  //
  G4LogicalVolume*    motherLogical  = motherPhysical->GetLogicalVolume();
  G4SmartVoxelHeader* pVoxelHeader   = motherLogical->GetVoxelHeader();
 
  switch( CharacteriseDaughters(motherLogical) )
  {
    case kNormal:
      if ( pVoxelHeader != nullptr )
      {
        fvoxelNav.VoxelLocate( pVoxelHeader, pointLocal );
      }
      break;
    case kParameterised:
      if( GetDaughtersRegularStructureId(motherLogical) != 1 )
      {
        // Resets state & returns voxel node
        //
        fparamNav.ParamVoxelLocate( pVoxelHeader, pointLocal );
      }
      break;
    case kReplica:
      // Nothing to do
      break;
    case kExternal:
      fpExternalNav->RelocateWithinVolume( motherPhysical,
                                           pointLocal );
      break;
  }
}

Referenced by SafetyInCurrentVolume().

SafetyInCurrentVolume()

G4double G4SafetyCalculator::SafetyInCurrentVolume	(	const G4ThreeVector &	globalpoint,
		G4VPhysicalVolume *	physicalVolume,
		const G4double	pProposedMaxLength = DBL_MAX,
		G4bool	verbose = false )

Calculates the isotropic distance to the nearest boundary from the specified point in the global coordinate system.

Parameters

[in]	globalPoint	The point in global coordinates; it must be located exactly within the current volume (it also must not be in a daughter volume.
[in]	physicalVolume	Current volume.
[in]	pProposedMaxLength	The calculation will not look beyond the proposed maximum length to avoid extra volume safety calculations.
[in]	verbose	Flag to enable verbosity (default is false).

Returns

An underestimate of the safety distance (and typically will be if complex volumes are involved.

Definition at line 53 of file G4SafetyCalculator.cc.

{
  G4double safety = 0.0;
  G4ThreeVector stepEndPoint = fNavigator.GetLastStepEndPoint();
 
  G4ThreeVector localPoint = ComputeLocalPoint(pGlobalpoint);
  
  G4double distEndpointSq = (pGlobalpoint-stepEndPoint).mag2(); 
  G4bool stayedOnEndpoint = distEndpointSq < sqr(fkCarTolerance); 
  G4bool endpointOnSurface =   fNavigator.EnteredDaughterVolume()
                            || fNavigator.ExitedMotherVolume();
 
  G4VPhysicalVolume* motherPhysical = fNavHistory.GetTopVolume();
  if( motherPhysical != physicalVolume )
  {
     std::ostringstream msg;
     msg << " Current (navigation) phys-volume: " << motherPhysical
         << " name= " << motherPhysical->GetName() << G4endl
         << " Request made for     phys-volume: " << physicalVolume
         << " name= " << physicalVolume->GetName() << G4endl;
     G4Exception("G4SafetyCalculator::SafetyInCurrentVolume", "GeomNav0001",
                 FatalException, msg,
                 "This method must be called only in the Current volume.");
  }
 
  if( !(endpointOnSurface && stayedOnEndpoint) )
  {
    G4LogicalVolume* motherLogical = motherPhysical->GetLogicalVolume();
    G4SmartVoxelHeader* pVoxelHeader = motherLogical->GetVoxelHeader();
 
    // Pseudo-relocate to this point (updates voxel information only)
    //
    QuickLocateWithinVolume( localPoint, motherPhysical ); 
    //*********************
 
    // switch(CharacteriseDaughters(motherLogical))
    auto dtype= CharacteriseDaughters(motherLogical);
    switch(dtype)
    {
      case kNormal:
        if ( pVoxelHeader != nullptr ) 
        {
          // New way: best safety
          safety = fVoxelSafety.ComputeSafety(localPoint,
                                               *motherPhysical, pMaxLength);
        }
        else
        {
          safety=fnormalNav.ComputeSafety(localPoint,fNavHistory,pMaxLength);
        }
        break;
      case kParameterised:
        if( GetDaughtersRegularStructureId(motherLogical) != 1 )
        {
          safety=fparamNav.ComputeSafety(localPoint,fNavHistory,pMaxLength);
        }
        else  // Regular structure
        {
          safety=fregularNav.ComputeSafety(localPoint,fNavHistory,pMaxLength);
        }
        break;
      case kReplica:
        safety = freplicaNav.ComputeSafety(pGlobalpoint, localPoint,
                                           fNavHistory, pMaxLength);
        break;
      case kExternal:
        safety = fpExternalNav->ComputeSafety(localPoint, fNavHistory,
                                              pMaxLength);
        break;
    }
 
    // Remember last safety origin & value
    //
    fPreviousSftOrigin = pGlobalpoint;
    fPreviousSafety = safety;
  }
 
  return safety;
}

Referenced by CompareSafetyValues().

SetExternalNavigation()

void G4SafetyCalculator::SetExternalNavigation

(

G4VExternalNavigation *

externalNav

)

Definition at line 202 of file G4SafetyCalculator.cc.

{
  fpExternalNav = eNav;
}

---

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

• G4SafetyCalculator.hh
• G4SafetyCalculator.cc