G4ParameterisedNavigation Class Reference

#include <G4ParameterisedNavigation.hh>

Inheritance diagram for G4ParameterisedNavigation:

Collaboration diagram for G4ParameterisedNavigation:

Public Member Functions
	G4ParameterisedNavigation ()
	~G4ParameterisedNavigation ()
G4SmartVoxelNode *	ParamVoxelLocate (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)
G4bool	LevelLocate (G4NavigationHistory &history, const G4VPhysicalVolume *blockedVol, const G4int blockedNum, const G4ThreeVector &globalPoint, const G4ThreeVector *globalDirection, const G4bool pLocatedOnEdge, G4ThreeVector &localPoint)
G4double	ComputeStep (const G4ThreeVector &globalPoint, const G4ThreeVector &globalDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume *(*pBlockedPhysical), G4int &blockedReplicaNo)
G4double	ComputeSafety (const G4ThreeVector &localPoint, const G4NavigationHistory &history, const G4double pProposedMaxLength=DBL_MAX)
Public Member Functions inherited from G4VoxelNavigation
	G4VoxelNavigation ()
virtual	~G4VoxelNavigation ()
G4SmartVoxelNode *	VoxelLocate (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint)
G4int	GetVerboseLevel () const
void	SetVerboseLevel (G4int level)
void	CheckMode (G4bool mode)
void	EnableBestSafety (G4bool flag=false)

Additional Inherited Members
Protected Member Functions inherited from G4VoxelNavigation
G4double	ComputeVoxelSafety (const G4ThreeVector &localPoint) const
G4bool	LocateNextVoxel (const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentStep)
G4SmartVoxelNode *	VoxelLocateLight (G4SmartVoxelHeader *pHead, const G4ThreeVector &localPoint) const
Protected Attributes inherited from G4VoxelNavigation
G4BlockingList	fBList
G4int	fVoxelDepth
std::vector< EAxis >	fVoxelAxisStack
std::vector< G4int >	fVoxelNoSlicesStack
std::vector< G4double >	fVoxelSliceWidthStack
std::vector< G4int >	fVoxelNodeNoStack
std::vector< G4SmartVoxelHeader * >	fVoxelHeaderStack
G4SmartVoxelNode *	fVoxelNode
G4VoxelSafety *	fpVoxelSafety
G4double	fHalfTolerance
G4bool	fCheck
G4bool	fBestSafety
G4NavigationLogger *	fLogger

Detailed Description

Definition at line 58 of file G4ParameterisedNavigation.hh.

Constructor & Destructor Documentation

G4ParameterisedNavigation::G4ParameterisedNavigation

(

)

Definition at line 60 of file G4ParameterisedNavigation.cc.

  : fVoxelAxis(kUndefined), fVoxelNoSlices(0), fVoxelSliceWidth(0.),
    fVoxelNodeNo(0), fVoxelHeader(0)
{
}

G4ParameterisedNavigation::~G4ParameterisedNavigation

(

)

Definition at line 70 of file G4ParameterisedNavigation.cc.

{
}

Member Function Documentation

G4double G4ParameterisedNavigation::ComputeSafety ( const G4ThreeVector &  localPoint, const G4NavigationHistory &  history, const G4double  pProposedMaxLength = DBL_MAX  )

virtual

Reimplemented from G4VoxelNavigation.

Definition at line 399 of file G4ParameterisedNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical;
  G4VPVParameterisation *sampleParam;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid, *sampleSolid;
  G4double motherSafety, ourSafety;
  G4int sampleNo, curVoxelNodeNo;

  G4SmartVoxelNode *curVoxelNode;
  G4int curNoVolumes, contentNo;
  G4double voxelSafety;

  // Replication data
  //
  EAxis axis;
  G4int nReplicas;
  G4double width, offset;
  G4bool consuming;

  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  motherSolid = motherLogical->GetSolid();

  //
  // Compute mother safety
  //

  motherSafety = motherSolid->DistanceToOut(localPoint);
  ourSafety = motherSafety;                     // Working isotropic safety

  //
  // Compute daughter safeties
  //

  // By definition, parameterised volumes exist as first
  // daughter of the mother volume
  //
  samplePhysical = motherLogical->GetDaughter(0);
  samplePhysical->GetReplicationData(axis, nReplicas,
                                     width, offset, consuming);
  sampleParam = samplePhysical->GetParameterisation();

  // Look inside the current Voxel only at the current point
  //
  if ( axis==kUndefined )      // 3D case: current voxel node is retrieved
  {                            //          from G4VoxelNavigation.
    curVoxelNode = fVoxelNode;
  }
  else                         // 1D case: current voxel node is computed here.
  {
    curVoxelNodeNo = G4int((localPoint(fVoxelAxis)
                           -fVoxelHeader->GetMinExtent()) / fVoxelSliceWidth );
    curVoxelNode = fVoxelHeader->GetSlice(curVoxelNodeNo)->GetNode();
    fVoxelNodeNo = curVoxelNodeNo;
    fVoxelNode = curVoxelNode;
  }
  curNoVolumes = curVoxelNode->GetNoContained();

  for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
  {
    sampleNo = curVoxelNode->GetVolume(contentNo);
    
    // Call virtual methods, and copy information if needed
    //
    sampleSolid= IdentifyAndPlaceSolid( sampleNo,samplePhysical,sampleParam ); 

    G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                               samplePhysical->GetTranslation());
    sampleTf.Invert();
    const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
    G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
    if ( sampleSafety<ourSafety )
    {
      ourSafety = sampleSafety;
    }
  }

  voxelSafety = ComputeVoxelSafety(localPoint,axis);
  if ( voxelSafety<ourSafety )
  {
    ourSafety=voxelSafety;
  }

  return ourSafety;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4ParameterisedNavigation::ComputeStep ( const G4ThreeVector &  globalPoint, const G4ThreeVector &  globalDirection, const G4double  currentProposedStepLength, G4double &  newSafety, G4NavigationHistory &  history, G4bool &  validExitNormal, G4ThreeVector &  exitNormal, G4bool &  exiting, G4bool &  entering, G4VPhysicalVolume **  pBlockedPhysical, G4int &  blockedReplicaNo  )

virtual

Reimplemented from G4VoxelNavigation.

Definition at line 79 of file G4ParameterisedNavigation.cc.

{
  G4VPhysicalVolume *motherPhysical, *samplePhysical;
  G4VPVParameterisation *sampleParam;
  G4LogicalVolume *motherLogical;
  G4VSolid *motherSolid, *sampleSolid;
  G4ThreeVector sampleDirection;
  G4double ourStep=currentProposedStepLength, ourSafety;
  G4double motherSafety, motherStep=DBL_MAX;
  G4bool motherValidExitNormal=false;
  G4ThreeVector motherExitNormal;
  
  G4int sampleNo;

  G4bool initialNode, noStep;
  G4SmartVoxelNode *curVoxelNode;
  G4int curNoVolumes, contentNo;
  G4double voxelSafety;

  // Replication data
  //
  EAxis axis;
  G4int nReplicas;
  G4double width, offset;
  G4bool consuming;

  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 )
  {
    if( motherSafety < 0.0 )
    {
      motherSolid->DumpInfo();
      std::ostringstream message;
      message << "Negative Safety In Voxel Navigation !" << G4endl
              << "        Current solid " << motherSolid->GetName()
              << " gave negative safety: " << motherSafety << G4endl
              << "        for the current (local) point " << localPoint;
      G4Exception("G4ParameterisedNavigation::ComputeStep()",
                  "GeomNav0003", FatalException, message); 
    }
    if( motherSolid->Inside(localPoint)==kOutside )
    { 
      std::ostringstream message;
      message << "Point is outside Current Volume !" << G4endl
              << "          Point " << localPoint
              << " is outside current volume " << motherPhysical->GetName()
              << G4endl;
      G4double  estDistToSolid= motherSolid->DistanceToIn(localPoint); 
      G4cout << "          Estimated isotropic distance to solid (distToIn)= " 
             << estDistToSolid;
      if( estDistToSolid > 100.0 * motherSolid->GetTolerance() )
      {
        motherSolid->DumpInfo();
        G4Exception("G4ParameterisedNavigation::ComputeStep()",
                    "GeomNav0003", FatalException, message,
                    "Point is far outside Current Volume !"); 
      }
      else
        G4Exception("G4ParameterisedNavigation::ComputeStep()",
                    "GeomNav1002", JustWarning, message,
                    "Point is a little outside Current Volume."); 
    }

    // 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= 0; // or motherPhysical ?
      blockedReplicaNo= 0;  // or motherReplicaNumber ?
    
      newSafety= 0.0;
      return ourStep;
    }
  }
#endif

  initialNode = true;
  noStep = true;

  // By definition, the parameterised volume is the first
  // (and only) daughter of the mother volume
  //
  samplePhysical = motherLogical->GetDaughter(0);
  samplePhysical->GetReplicationData(axis,nReplicas,width,offset,consuming);
  fBList.Enlarge(nReplicas);
  fBList.Reset();

  // Exiting normal optimisation
  //
  if (exiting && (*pBlockedPhysical==samplePhysical) && validExitNormal)
  {
    if (localDirection.dot(exitNormal)>=kMinExitingNormalCosine)
    {
      // Block exited daughter replica; Must be on boundary => zero safety
      //
      fBList.BlockVolume(blockedReplicaNo);
      ourSafety = 0;
    }
  }
  exiting = false;
  entering = false;

  sampleParam = samplePhysical->GetParameterisation();

  // Loop over voxels & compute daughter safeties & intersections

  do
  {
    curVoxelNode = fVoxelNode;
    curNoVolumes = curVoxelNode->GetNoContained();

    for ( contentNo=curNoVolumes-1; contentNo>=0; contentNo-- )
    {
      sampleNo = curVoxelNode->GetVolume(contentNo);
      if ( !fBList.IsBlocked(sampleNo) )
      {
        fBList.BlockVolume(sampleNo);

        // Call virtual methods, and copy information if needed
        //
        sampleSolid = IdentifyAndPlaceSolid( sampleNo, samplePhysical,
                                             sampleParam ); 

        G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                                   samplePhysical->GetTranslation());
        sampleTf.Invert();
        const G4ThreeVector samplePoint = sampleTf.TransformPoint(localPoint);
        const G4double sampleSafety = sampleSolid->DistanceToIn(samplePoint);
        if ( sampleSafety<ourSafety )
        {
          ourSafety = sampleSafety;
        }
        if ( sampleSafety<=ourStep )
        {
          sampleDirection = sampleTf.TransformAxis(localDirection);
          G4double sampleStep =
                   sampleSolid->DistanceToIn(samplePoint, sampleDirection);
          if ( sampleStep<=ourStep )
          {
            ourStep = sampleStep;
            entering = true;
            exiting = false;
            *pBlockedPhysical = samplePhysical;
            blockedReplicaNo = sampleNo;
#ifdef G4VERBOSE
              // Check to see that the resulting point is indeed in/on volume.
              // This check could eventually be made only for successful
              // candidate.

              if ( ( fCheck ) && ( sampleStep < kInfinity ) )
              {
                G4ThreeVector intersectionPoint;
                intersectionPoint= samplePoint + sampleStep * sampleDirection;
                EInside insideIntPt= sampleSolid->Inside(intersectionPoint); 
                if( insideIntPt != kSurface )
                {
                  G4int oldcoutPrec = G4cout.precision(16); 
                  std::ostringstream message;
                  message << "Navigator gets conflicting response from Solid."
                          << G4endl
                          << "          Inaccurate solid DistanceToIn"
                          << " for solid " << sampleSolid->GetName() << G4endl
                          << "          Solid gave DistanceToIn = "
                          << sampleStep << " yet returns " ;
                  if( insideIntPt == kInside )
                    message << "-kInside-"; 
                  else if( insideIntPt == kOutside )
                    message << "-kOutside-";
                  else
                    message << "-kSurface-"; 
                  message << " for this point !" << G4endl
                          << "          Point = " << intersectionPoint
                          << G4endl;
                  if ( insideIntPt != kInside )
                    message << "        DistanceToIn(p) = " 
                            << sampleSolid->DistanceToIn(intersectionPoint);
                  if ( insideIntPt != kOutside ) 
                    message << "        DistanceToOut(p) = " 
                            << sampleSolid->DistanceToOut(intersectionPoint);
                  G4Exception("G4ParameterisedNavigation::ComputeStep()", 
                              "GeomNav1002", JustWarning, message);
                  G4cout.precision(oldcoutPrec);
                }
              }
#endif
          }
        }
      }
    }

    if ( initialNode )
    {
      initialNode = false;
      voxelSafety = ComputeVoxelSafety(localPoint,axis);
      if ( voxelSafety<ourSafety )
      {
        ourSafety = voxelSafety;
      }
      if ( currentProposedStepLength<ourSafety )
      {
        // Guaranteed physics limited
        //      
        noStep = false;
        entering = false;
        exiting = false;
        *pBlockedPhysical = 0;
        ourStep = kInfinity;
      }
      else
      {
        // Consider intersection with mother solid
        //
        if ( motherSafety<=ourStep )
        {
          if ( !fCheck )           
          {
            motherStep = motherSolid->DistanceToOut(localPoint,
                                                   localDirection,
                                                   true,
                                                   &motherValidExitNormal,
                                                   &motherExitNormal);
          }

          if( ( motherStep < 0.0 ) || ( motherStep >= kInfinity) )
          {
#ifdef G4VERBOSE
            fLogger->ReportOutsideMother(localPoint, localDirection, motherPhysical);
#endif
            ourStep = motherStep = 0.0;
            // Rely on the code below to set the remaining state, i.e.
            // exiting, entering,  exitNormal & validExitNormal,
            // pBlockedPhysical etc.
          }
#ifdef G4VERBOSE
          if( motherValidExitNormal && ( fCheck || (motherStep<=ourStep)) )
          {
            fLogger->CheckAndReportBadNormal(motherExitNormal,
                                             localPoint, localDirection,
                                             motherStep, motherSolid,
                                             "From motherSolid::DistanceToOut");
          }
#endif
          if ( motherStep<=ourStep )
          {
            ourStep = motherStep;
            exiting = true;
            entering = false;
            if ( validExitNormal )
            {
              const G4RotationMatrix *rot = motherPhysical->GetRotation();
              if (rot)
              {
                exitNormal *= rot->inverse();
              }
            }
          }
          else
          {
            validExitNormal = false;
          }
        }
      }
      newSafety=ourSafety;
    }
    if (noStep)
    {
      noStep = LocateNextVoxel(localPoint, localDirection, ourStep, axis);
    }
  } while (noStep);

  return ourStep;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Reimplemented from G4VoxelNavigation.

Definition at line 605 of file G4ParameterisedNavigation.cc.

{
  G4SmartVoxelHeader *motherVoxelHeader;
  G4SmartVoxelNode *motherVoxelNode;
  G4VPhysicalVolume *motherPhysical, *pPhysical;
  G4VPVParameterisation *pParam;
  G4LogicalVolume *motherLogical;
  G4VSolid *pSolid;
  G4ThreeVector samplePoint;
  G4int voxelNoDaughters, replicaNo;
  
  motherPhysical = history.GetTopVolume();
  motherLogical = motherPhysical->GetLogicalVolume();
  motherVoxelHeader = motherLogical->GetVoxelHeader();

  // Find the voxel containing the point
  //
  motherVoxelNode = ParamVoxelLocate(motherVoxelHeader,localPoint);
  
  voxelNoDaughters = motherVoxelNode->GetNoContained();
  if ( voxelNoDaughters==0 )  { return false; }
  
  pPhysical = motherLogical->GetDaughter(0);
  pParam = pPhysical->GetParameterisation();

  // Save parent history in touchable history
  //   ... for use as parent t-h in ComputeMaterial method of param
  //
  G4TouchableHistory parentTouchable( history ); 

  // Search replicated daughter volume
  //
  for ( G4int sampleNo=voxelNoDaughters-1; sampleNo>=0; sampleNo-- )
  {
    replicaNo = motherVoxelNode->GetVolume(sampleNo);
    if ( (replicaNo!=blockedNum) || (pPhysical!=blockedVol) )
    {
      // Obtain solid (as it can vary) and obtain its parameters
      //
      pSolid = IdentifyAndPlaceSolid( replicaNo, pPhysical, pParam ); 

      // Setup history
      //
      history.NewLevel(pPhysical, kParameterised, replicaNo);
      samplePoint = history.GetTopTransform().TransformPoint(globalPoint);
      if ( !G4AuxiliaryNavServices::CheckPointOnSurface( pSolid, samplePoint,
            globalDirection, history.GetTopTransform(), pLocatedOnEdge) )
      {
        history.BackLevel();
      }
      else
      { 
        // Enter this daughter
        //
        localPoint = samplePoint;
        
        // Set the correct copy number in physical
        //
        pPhysical->SetCopyNo(replicaNo);
        
        // Set the correct solid and material in Logical Volume
        //
        G4LogicalVolume *pLogical = pPhysical->GetLogicalVolume();
        pLogical->SetSolid(pSolid);
        pLogical->UpdateMaterial(pParam->ComputeMaterial(replicaNo,
                                 pPhysical, &parentTouchable)  );
        return true;
      }
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4SmartVoxelNode* G4ParameterisedNavigation::ParamVoxelLocate ( G4SmartVoxelHeader *  pHead, const G4ThreeVector &  localPoint  )

inline

Here is the caller graph for this function:

---

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

• geant4.10.03.p01/source/geometry/navigation/include/G4ParameterisedNavigation.hh
• geant4.10.03.p01/source/geometry/navigation/src/G4ParameterisedNavigation.cc