G4SafetyCalculator Class Reference

#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

Definition at line 67 of file G4SafetyCalculator.hh.

Constructor & Destructor Documentation

G4SafetyCalculator() [1/2]

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

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

~G4SafetyCalculator()

G4SafetyCalculator::~G4SafetyCalculator ( )

default

Member Function Documentation

CharacteriseDaughters()

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

inlineprotected

Definition at line 185 of file G4SafetyCalculator.hh.

{
  return pLog->CharacteriseDaughters();
}

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 )

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

Definition at line 179 of file G4SafetyCalculator.hh.

{
  return fNavHistory.GetTopTransform().TransformAxis(pVec);
}

ComputeLocalPoint()

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

inlineprotected

Definition at line 171 of file G4SafetyCalculator.hh.

{
  return fNavHistory.GetTopTransform().TransformPoint(pGlobalPoint);
}

Referenced by SafetyInCurrentVolume().

GetDaughtersRegularStructureId()

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

inlineprotected

Definition at line 191 of file G4SafetyCalculator.hh.

{
  G4int regId = 0;
  G4VPhysicalVolume *pVol;
 
  if ( pLog->GetNoDaughters() == 1 )
  {
    pVol = pLog->GetDaughter(0);
    regId = pVol->GetRegularStructureId();
  }
  return regId;
}

Referenced by QuickLocateWithinVolume(), and SafetyInCurrentVolume().

GetExternalNavigation()

G4VExternalNavigation * G4SafetyCalculator::GetExternalNavigation

(

)

const

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

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

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 ) 
        {
          // 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