G4NormalNavigation Class Reference

G4NormalNavigation is a concrete utility class for navigation in volumes containing only G4PVPlacement daughter volumes. More...

#include <G4NormalNavigation.hh>

Inheritance diagram for G4NormalNavigation:

Public Member Functions
	G4NormalNavigation ()
	~G4NormalNavigation () override
G4bool	LevelLocate (G4NavigationHistory &history, const G4VPhysicalVolume *blockedVol, const G4int blockedNum, const G4ThreeVector &globalPoint, const G4ThreeVector *globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector &localPoint) final
G4double	ComputeStep (const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume *(*pBlockedPhysical), G4int &blockedReplicaNo) final
G4double	ComputeSafety (const G4ThreeVector &localpoint, const G4NavigationHistory &history, const G4double pMaxLength=DBL_MAX) final
G4int	GetVerboseLevel () const final
void	SetVerboseLevel (G4int level) final
Public Member Functions inherited from G4VNavigation
virtual	~G4VNavigation ()=default
virtual void	RelocateWithinVolume (G4VPhysicalVolume *, const G4ThreeVector &)
void	CheckMode (G4bool mode)

Additional Inherited Members
Protected Attributes inherited from G4VNavigation
G4int	fVerbose = 0
G4bool	fCheck = false

Detailed Description

G4NormalNavigation is a concrete utility class for navigation in volumes containing only G4PVPlacement daughter volumes.

Definition at line 56 of file G4NormalNavigation.hh.

Constructor & Destructor Documentation

G4NormalNavigation()

G4NormalNavigation::G4NormalNavigation

(

)

Constructor and Destructor.

Definition at line 39 of file G4NormalNavigation.cc.

{
  fLogger = new G4NavigationLogger("G4NormalNavigation");
}

~G4NormalNavigation()

G4NormalNavigation::~G4NormalNavigation ( )

override

Definition at line 48 of file G4NormalNavigation.cc.

{
  delete fLogger;
}

Member Function Documentation

ComputeSafety()

G4double G4NormalNavigation::ComputeSafety ( const G4ThreeVector & localpoint, const G4NavigationHistory & history, const G4double pMaxLength = DBL_MAX )

finalvirtual

Calculates the isotropic distance to the nearest boundary from the specified point in the local coordinate system. The localpoint utilised must be within the current volume.

Parameters

[in]	localPoint	Local point.
[in]	history	Navigation history.
[in]	pMaxLength	Maximum step length beyond which volumes need not be checked.

Returns

Length from current point to closest surface.

Implements G4VNavigation.

Definition at line 333 of file G4NormalNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid;
  G4double motherSafety, ourSafety;
  G4long localNoDaughters, sampleNo;
 
  motherPhysical = history.GetTopVolume();
  motherLogical  = motherPhysical->GetLogicalVolume();
  motherSolid    = motherLogical->GetSolid();
 
  // Compute mother safety
  //
  motherSafety = motherSolid->DistanceToOut(localPoint);
  ourSafety = motherSafety; // Working isotropic safety
 
#ifdef G4VERBOSE
  if( fCheck )
  {
    fLogger->ComputeSafetyLog(motherSolid,localPoint,motherSafety,true,1);
  }
#endif
 
  // Compute daughter safeties 
  //
  localNoDaughters = motherLogical->GetNoDaughters();
  for ( sampleNo=localNoDaughters-1; sampleNo>=0; sampleNo-- )
  {
    samplePhysical = motherLogical->GetDaughter(sampleNo);
    G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                               samplePhysical->GetTranslation());
    sampleTf.Invert();
    const G4ThreeVector samplePoint =
            sampleTf.TransformPoint(localPoint);
    const G4VSolid *sampleSolid =
            samplePhysical->GetLogicalVolume()->GetSolid();
    const G4double sampleSafety =
            sampleSolid->DistanceToIn(samplePoint);
    if ( sampleSafety<ourSafety )
    {
      ourSafety = sampleSafety;
    }
#ifdef G4VERBOSE
    if(fCheck)
    {
      fLogger->ComputeSafetyLog(sampleSolid, samplePoint,
                                sampleSafety, false, 0);
        // Not mother, no banner
    }
#endif
  }
  return ourSafety;
}

ComputeStep()

G4double G4NormalNavigation::ComputeStep ( const G4ThreeVector & localPoint, const G4ThreeVector & localDirection, const G4double currentProposedStepLength, G4double & newSafety, G4NavigationHistory & history, G4bool & validExitNormal, G4ThreeVector & exitNormal, G4bool & exiting, G4bool & entering, G4VPhysicalVolume ** pBlockedPhysical, G4int & blockedReplicaNo )

finalvirtual

Computes the length of a step to the next boundary. Does not test against pBlockedPhysical. Identifies the next candidate volume (if a daughter of the current volume), and returns it in: pBlockedPhysical, blockedReplicaNo.

Parameters

[in]	localPoint	Local point.
[in]	localDirection	Pointer to local direction or null pointer.
[in]	currentProposedStepLength	Current proposed step length.
[in,out]	newSafety	New safety.
[in,out]	history	Navigation history.
[in,out]	validExitNormal	Flag to indicate whether exit normal is valid or not.
[in,out]	exitNormal	Exit normal.
[in,out]	exiting	Flag to indicate whether exiting a volume.
[in,out]	entering	Flag to indicate whether entering a volume.
[in,out]	pBlockedPhysical	Blocked physical volume that should be ignored in queries.
[in,out]	blockedReplicaNo	Copy number for blocked replica volumes.

Returns

Length from current point to next boundary surface along localDirection.

Implements G4VNavigation.

Definition at line 63 of file G4NormalNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical,
                    *blockedExitedVol = nullptr;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid;
  G4ThreeVector sampleDirection;
  G4double ourStep = currentProposedStepLength, ourSafety;
  G4double motherSafety, motherStep = DBL_MAX;
  G4long localNoDaughters, sampleNo;
  G4bool motherValidExitNormal = false;
  G4ThreeVector motherExitNormal; 
 
  motherPhysical = history.GetTopVolume();
  motherLogical  = motherPhysical->GetLogicalVolume();
  motherSolid    = motherLogical->GetSolid();
 
  // Compute mother safety
  //
  motherSafety = motherSolid->DistanceToOut(localPoint);
  ourSafety = motherSafety; // Working isotropic safety
 
  localNoDaughters = motherLogical->GetNoDaughters();
  
#ifdef G4VERBOSE
  if ( fCheck && ( (localNoDaughters>0) || (ourStep < motherSafety) )  )
  {
    fLogger->PreComputeStepLog(motherPhysical, motherSafety, localPoint);
  }
#endif
  // Compute daughter safeties & intersections
  //
 
  // Exiting normal optimisation
  //
  if ( exiting && validExitNormal )
  {
    if ( localDirection.dot(exitNormal)>=kMinExitingNormalCosine )
    {
      // Block exited daughter volume
      //
      blockedExitedVol = (*pBlockedPhysical);
      ourSafety = 0;
    }
  }
  exiting  = false;
  entering = false;
 
#ifdef G4VERBOSE
  if ( fCheck )
  {
    // Compute early:
    //  a) to check whether point is (wrongly) outside
    //               (signaled if step < 0 or step == kInfinity )
    //  b) to check value against answer of daughters!
 
    motherStep = motherSolid->DistanceToOut(localPoint,
                                            localDirection,
                                            true,
                                           &motherValidExitNormal,
                                           &motherExitNormal);
 
    if( (motherStep >= kInfinity) || (motherStep < 0.0) )
    {
      // Error - indication of being outside solid !!
      fLogger->ReportOutsideMother(localPoint, localDirection, motherPhysical);
    
      ourStep = motherStep = 0.0;
   
      exiting = true;
      entering = false;
    
      // If we are outside the solid does the normal make sense?
      validExitNormal = motherValidExitNormal;
      exitNormal = motherExitNormal;
    
      *pBlockedPhysical = nullptr; // or motherPhysical ?
      blockedReplicaNo = 0;  // or motherReplicaNumber ?
    
      newSafety = 0.0;
      return ourStep;
    }
  }
#endif
 
  for ( sampleNo=localNoDaughters-1; sampleNo>=0; sampleNo--)
  {
    samplePhysical = motherLogical->GetDaughter(sampleNo);
    if ( samplePhysical!=blockedExitedVol )
    {
      G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                                 samplePhysical->GetTranslation());
      sampleTf.Invert();
      const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
      const G4VSolid *sampleSolid =
              samplePhysical->GetLogicalVolume()->GetSolid();
      const G4double sampleSafety =
              sampleSolid->DistanceToIn(samplePoint);
 
      if ( sampleSafety<ourSafety )
      {
        ourSafety=sampleSafety;
      }
    
      if ( sampleSafety<=ourStep )
      {
        sampleDirection = sampleTf.TransformAxis(localDirection);
        const G4double sampleStep =
                sampleSolid->DistanceToIn(samplePoint,sampleDirection);
#ifdef G4VERBOSE        
        if( fCheck )
        {
          fLogger->PrintDaughterLog(sampleSolid, samplePoint,
                                    sampleSafety, true,
                                    sampleDirection, sampleStep);          
        }
#endif
        if ( sampleStep<=ourStep )
        {
          ourStep  = sampleStep;
          entering = true;
          exiting  = false;
          *pBlockedPhysical = samplePhysical;
          blockedReplicaNo  = -1;
#ifdef G4VERBOSE
          if( fCheck )
          {
            fLogger->AlongComputeStepLog(sampleSolid, samplePoint,
                                         sampleDirection, localDirection,
                                         sampleSafety, sampleStep);
          }
#endif          
        }
 
#ifdef G4VERBOSE
        if( fCheck && (sampleStep < kInfinity) && (sampleStep >= motherStep) )
        {
           // The intersection point with the daughter is at or after the exit
           // point from the mother volume.  Double check!
           fLogger->CheckDaughterEntryPoint(sampleSolid,
                                            samplePoint, sampleDirection,
                                            motherSolid,
                                            localPoint, localDirection,
                                            motherStep, sampleStep);
        }
#endif
      } // end of if ( sampleSafety <= ourStep ) 
#ifdef G4VERBOSE
      else if ( fCheck )
      {
         fLogger->PrintDaughterLog(sampleSolid, samplePoint,
                                   sampleSafety, false,
                                   G4ThreeVector(0.,0.,0.), -1.0 );
      }
#endif          
    }
  }
  if ( currentProposedStepLength<ourSafety )
  {
    // Guaranteed physics limited
    //
    entering = false;
    exiting  = false;
    *pBlockedPhysical = nullptr;
    ourStep = kInfinity;
  }
  else
  {
    // Consider intersection with mother solid
    //
    if ( motherSafety<=ourStep )
    {
      if ( !fCheck )  // The call is moved above when running in check_mode
      {
        motherStep = motherSolid->DistanceToOut(localPoint,
                                                localDirection,
                                                true,
                                               &motherValidExitNormal,
                                               &motherExitNormal);
      }
#ifdef G4VERBOSE
      else  // check_mode
      {
        fLogger->PostComputeStepLog(motherSolid, localPoint, localDirection,
                                    motherStep, motherSafety);
        if( motherValidExitNormal )
        {
          fLogger->CheckAndReportBadNormal(motherExitNormal,
                                           localPoint,
                                           localDirection,
                                           motherStep,
                                           motherSolid,
                                           "From motherSolid::DistanceToOut" );
        }
      }
#endif
 
      if( (motherStep >= kInfinity) || (motherStep < 0.0) )
      {
#ifdef G4VERBOSE
        if( fCheck )  // Clearly outside the mother solid!
        {
          fLogger->ReportOutsideMother(localPoint, localDirection,
                                       motherPhysical);
        }
#endif
        ourStep = motherStep = 0.0;
        exiting = true;
        entering = false;
        // validExitNormal= motherValidExitNormal;
        // exitNormal= motherExitNormal;
        //  The normal could be useful - but only if near the mother
        //  But it could be unreliable!
        validExitNormal = false;
        *pBlockedPhysical = nullptr; // or motherPhysical ?
        blockedReplicaNo = 0;  // or motherReplicaNumber ?
        newSafety= 0.0;
        return ourStep;
      }
 
      if ( motherStep<=ourStep )
      {
        ourStep  = motherStep;
        exiting  = true;
        entering = false;
        validExitNormal = motherValidExitNormal;
        exitNormal = motherExitNormal;
        
        if ( motherValidExitNormal )
        {
          const G4RotationMatrix *rot = motherPhysical->GetRotation();
          if (rot != nullptr)
          {
            exitNormal *= rot->inverse();
#ifdef G4VERBOSE
            if( fCheck )
            {
               fLogger->CheckAndReportBadNormal(exitNormal,        // rotated
                                                motherExitNormal,  // original 
                                                *rot,
                                                "From RotationMatrix" );
            }
#endif            
          }
        }
      }
      else
      {
        validExitNormal = false;
      }
    }
  }
  newSafety = ourSafety;
  return ourStep;
}

GetVerboseLevel()

G4int G4NormalNavigation::GetVerboseLevel ( ) const

finalvirtual

Verbosity control.

Note

If level>0 && G4VERBOSE, printout can occur.

Reimplemented from G4VNavigation.

Definition at line 398 of file G4NormalNavigation.cc.

{
  return fLogger->GetVerboseLevel();
}

LevelLocate()

G4bool G4NormalNavigation::LevelLocate ( G4NavigationHistory & history, const G4VPhysicalVolume * blockedVol, const G4int blockedNum, const G4ThreeVector & globalPoint, const G4ThreeVector * globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector & localPoint )

inlinefinalvirtual

Searches positioned volumes in mother at current top level of history for volume containing globalPoint. Do not test against blockedVol. If a containing volume is found, push it onto navigation history state and return true, else return false (the point lying in the mother but not any of the daughters).

Parameters

[in,out]	history	Navigation history.
[in,out]	blockedVol	Blocked volume to be ignored in queries.
[in,out]	blockedNum	Copy number for blocked volumes.
[in,out]	globalPoint	Point in global coordinates system.
[in,out]	globalDirection	Pointer to global direction or null.
[in]	pLocatedOnEdge	Flag specifying if point is located on edge.
[in,out]	localPoint	Point in local coordinates system.

Returns

Whether a containing volume has been found.

Implements G4VNavigation.

SetVerboseLevel()

void G4NormalNavigation::SetVerboseLevel ( G4int level )

finalvirtual

Sets current verbosity level.

Reimplemented from G4VNavigation.

Definition at line 407 of file G4NormalNavigation.cc.

{
  fLogger->SetVerboseLevel(level);
}

Referenced by LevelLocate().

---

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

• G4NormalNavigation.hh
• G4NormalNavigation.cc