#include <G4ReplicaNavigation.hh>

Public Member Functions
	G4ReplicaNavigation ()

	~G4ReplicaNavigation ()

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 G4ThreeVector &localPoint, const G4ThreeVector &localDirection, const G4double currentProposedStepLength, G4double &newSafety, G4NavigationHistory &history, G4bool &validExitNormal, G4bool &calculatedExitNormal, G4ThreeVector &exitNormal, G4bool &exiting, G4bool &entering, G4VPhysicalVolume (pBlockedPhysical), G4int &blockedReplicaNo)

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

EInside	BackLocate (G4NavigationHistory &history, const G4ThreeVector &globalPoint, G4ThreeVector &localPoint, const G4bool &exiting, G4bool &notKnownInside) const

void	ComputeTransformation (const G4int replicaNo, G4VPhysicalVolume *pVol, G4ThreeVector &point) const

void	ComputeTransformation (const G4int replicaNo, G4VPhysicalVolume *pVol) const

EInside	Inside (const G4VPhysicalVolume *pVol, const G4int replicaNo, const G4ThreeVector &localPoint) const

G4double	DistanceToOut (const G4VPhysicalVolume *pVol, const G4int replicaNo, const G4ThreeVector &localPoint) const

G4double	DistanceToOut (const G4VPhysicalVolume *pVol, const G4int replicaNo, const G4ThreeVector &localPoint, const G4ThreeVector &localDirection, G4ExitNormal &candidateNormal) const

G4int	GetVerboseLevel () const

void	SetVerboseLevel (G4int level)

void	CheckMode (G4bool mode)

Detailed Description

Definition at line 82 of file G4ReplicaNavigation.hh.

Constructor & Destructor Documentation

G4ReplicaNavigation::G4ReplicaNavigation ( )

Definition at line 57 of file G4ReplicaNavigation.cc.

 : fCheck(false), fVerbose(0)
 {
   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
   kRadTolerance = G4GeometryTolerance::GetInstance()->GetRadialTolerance();
   kAngTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
   halfkCarTolerance = kCarTolerance*0.5;
   halfkRadTolerance = kRadTolerance*0.5;
   halfkAngTolerance = kAngTolerance*0.5;
   fMinStep = 0.05*kCarTolerance;
 }

Here is the call graph for this function:

G4ReplicaNavigation::~G4ReplicaNavigation ( )

Definition at line 73 of file G4ReplicaNavigation.cc.

74 {

75 }

Member Function Documentation

EInside G4ReplicaNavigation::BackLocate	(	G4NavigationHistory &	history,
		const G4ThreeVector &	globalPoint,
		G4ThreeVector &	localPoint,
		const G4bool &	exiting,
		G4bool &	notKnownInside
	)		const

Definition at line 1247 of file G4ReplicaNavigation.cc.

 {
   G4VPhysicalVolume *pNRMother=0;
   G4VSolid *motherSolid;
   G4ThreeVector repPoint, goodPoint;
   G4int mdepth, depth, cdepth;
   EInside insideCode;
 
   cdepth = history.GetDepth();
   
   // Find non replicated mother
   //
   for ( mdepth=cdepth-1; mdepth>=0; mdepth-- )
   {
     if ( history.GetVolumeType(mdepth)!=kReplica )
     {
       pNRMother = history.GetVolume(mdepth);
       break;
     }
   }
 
   if( pNRMother==0 ) 
   {
     // All the tree of mother volumes were Replicas. 
     // This is an error, as the World volume must be a Placement
     //
     G4Exception("G4ReplicaNavigation::BackLocate()", "GeomNav0002",
                 FatalException, "The World volume must be a Placement!");
     return kInside;
   }
 
   motherSolid = pNRMother->GetLogicalVolume()->GetSolid();
   goodPoint = history.GetTransform(mdepth).TransformPoint(globalPoint);
   insideCode = motherSolid->Inside(goodPoint);
   if ( (insideCode==kOutside)||((insideCode==kSurface)&&exiting) )
   {
     // Outside mother -> back up to mother level
     // Locate.. in Navigator will back up one more level
     // localPoint not required
     //
     history.BackLevel(cdepth-mdepth);
     //      localPoint = goodPoint;
   }
   else
   {
     notKnownInside = false;
 
     // Still within replications
     // Check down: if on outside stop at this level
     //
     for ( depth=mdepth+1; depth<cdepth; depth++)
     {
       repPoint = history.GetTransform(depth).TransformPoint(globalPoint);
       insideCode = Inside(history.GetVolume(depth),
                           history.GetReplicaNo(depth),
                           repPoint);
       if ( (insideCode==kOutside)||((insideCode==kSurface)&&exiting) )
       {
         localPoint = goodPoint;
         history.BackLevel(cdepth-depth);
         return insideCode;
       }
       else
       {
         goodPoint = repPoint;
       }
     }
     localPoint = history.GetTransform(depth).TransformPoint(globalPoint);
     insideCode = Inside(history.GetVolume(depth),
                         history.GetReplicaNo(depth),
                         localPoint);
     // If outside level, set localPoint = coordinates in reference system
     // of *previous* level - location code in navigator will back up one
     // level [And also manage blocking]
     //
     if ( (insideCode==kOutside)||((insideCode==kSurface)&&exiting) )
     {
       localPoint = goodPoint;
     }
   }
   return insideCode;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ReplicaNavigation::CheckMode ( G4bool mode )

inline

G4double G4ReplicaNavigation::ComputeSafety	(	const G4ThreeVector &	globalPoint,
		const G4ThreeVector &	localPoint,
		G4NavigationHistory &	history,
		const G4double	pProposedMaxLength = `DBL_MAX`
	)

Definition at line 1158 of file G4ReplicaNavigation.cc.

 {
   G4VPhysicalVolume *repPhysical, *motherPhysical;
   G4VPhysicalVolume *samplePhysical, *blockedExitedVol=0;
   G4LogicalVolume *repLogical;
   G4VSolid *motherSolid;
   G4ThreeVector repPoint;
   G4double ourSafety=kInfinity;
   G4double sampleSafety;
   G4int localNoDaughters, sampleNo;
   G4int depth;
 
   repPhysical = history.GetTopVolume();
   repLogical  = repPhysical->GetLogicalVolume();
 
   //
   // Compute intersection with replica boundaries & replica safety
   //
 
   sampleSafety = DistanceToOut(history.GetTopVolume(),
                                history.GetTopReplicaNo(),
                                localPoint);
   if ( sampleSafety<ourSafety )
   {
     ourSafety = sampleSafety;
   }
 
   depth = history.GetDepth()-1;
 
   // Loop checking, 07.10.2016, J.Apostolakis -- need to add: assert(depth>0)
   while ( history.GetVolumeType(depth)==kReplica )
   {      
     repPoint = history.GetTransform(depth).TransformPoint(globalPoint);
     sampleSafety = DistanceToOut(history.GetVolume(depth),
                                  history.GetReplicaNo(depth),
                                  repPoint);
     if ( sampleSafety<ourSafety )
     {
       ourSafety = sampleSafety;
     }
     depth--;
   }
 
   // Compute mother safety & intersection
   //
   repPoint = history.GetTransform(depth).TransformPoint(globalPoint);
   motherPhysical = history.GetVolume(depth);
   motherSolid = motherPhysical->GetLogicalVolume()->GetSolid();
   sampleSafety = motherSolid->DistanceToOut(repPoint);
 
   if ( sampleSafety<ourSafety )
   {
     ourSafety = sampleSafety;
   }
 
   // Compute daughter safeties & intersections
   //
   localNoDaughters = repLogical->GetNoDaughters();
   for ( sampleNo=localNoDaughters-1; sampleNo>=0; sampleNo-- )
   {
     samplePhysical = repLogical->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 sampleSafetyDistance =
                             sampleSolid->DistanceToIn(samplePoint);
       if ( sampleSafetyDistance<ourSafety )
       {
         ourSafety = sampleSafetyDistance;
       }
     }
   }
   return ourSafety;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 754 of file G4ReplicaNavigation.cc.

 {
   G4VPhysicalVolume *repPhysical, *motherPhysical;
   G4VPhysicalVolume *samplePhysical, *blockedExitedVol=0;
   G4LogicalVolume *repLogical;
   G4VSolid *motherSolid;
   G4ThreeVector repPoint, repDirection, sampleDirection;
   G4double ourStep=currentProposedStepLength;
   G4double ourSafety=kInfinity;
   G4double sampleStep, sampleSafety, motherStep, motherSafety;
   G4int localNoDaughters, sampleNo;
   G4int depth;
   G4ExitNormal exitNormalStc;
   // G4int depthDeterminingStep= -1; // Useful only for debugging - for now
 
   calculatedExitNormal= false;
   
   // Exiting normal optimisation
   //
   if ( exiting&&validExitNormal )
   {
     if ( localDirection.dot(exitNormalVector)>=kMinExitingNormalCosine )
     {
       // Block exited daughter volume
       //
       blockedExitedVol = *pBlockedPhysical;
       ourSafety = 0;
     }
   }
   exiting  = false;
   entering = false;
 
   repPhysical = history.GetTopVolume();
   repLogical  = repPhysical->GetLogicalVolume();
 
   //
   // Compute intersection with replica boundaries & replica safety
   //
 
   sampleSafety = DistanceToOut(repPhysical,
                                history.GetTopReplicaNo(),
                                localPoint);
   G4ExitNormal normalOutStc;
   const G4int topDepth= history.GetDepth();
 
   ourSafety = std::min( ourSafety, sampleSafety);
 
   if ( sampleSafety<ourStep )
   {
 
     sampleStep = DistanceToOut(repPhysical,
                                history.GetTopReplicaNo(),
                                localPoint,
                                localDirection,
                                normalOutStc);
     if ( sampleStep<ourStep )
     {
       ourStep = sampleStep;
       exiting = true;
       validExitNormal = normalOutStc.validConvex; // false; -> Old,Conservative
 
       exitNormalStc= normalOutStc;
       exitNormalStc.exitNormal= history.GetTopTransform().Inverse().
                                 TransformAxis(normalOutStc.exitNormal);
       calculatedExitNormal= true;
     }
   }
   const G4int secondDepth= topDepth;
   depth = secondDepth;  
 
   // Loop checking, 07.10.2016, J.Apostolakis -- Need to add: assert(depth>0)
   while ( history.GetVolumeType(depth)==kReplica )  
   {
     const G4AffineTransform& GlobalToLocal= history.GetTransform(depth);
     repPoint    = GlobalToLocal.TransformPoint(globalPoint);
     // repPoint = history.GetTransform(depth).TransformPoint(globalPoint);
  
     sampleSafety = DistanceToOut(history.GetVolume(depth),
                                  history.GetReplicaNo(depth),
                                  repPoint);
     if ( sampleSafety < ourSafety )
     {
       ourSafety = sampleSafety;
     }
     if ( sampleSafety < ourStep )
     {
       G4ThreeVector newLocalDirection =
           GlobalToLocal.TransformAxis(globalDirection);
       sampleStep = DistanceToOut(history.GetVolume(depth),
                                  history.GetReplicaNo(depth),
                                  repPoint,
                                  newLocalDirection,
                                  normalOutStc);
       if ( sampleStep < ourStep )
       {
         ourStep = sampleStep;
         exiting = true;
        
         // As step is limited by this level, must set Exit Normal
         //
         G4ThreeVector localExitNorm= normalOutStc.exitNormal;
         G4ThreeVector globalExitNorm=
             GlobalToLocal.Inverse().TransformAxis(localExitNorm);
 
         exitNormalStc= normalOutStc; // Normal, convex, calculated, side
         exitNormalStc.exitNormal= globalExitNorm;
         calculatedExitNormal= true;
       }
     }
     depth--;
   }
  
   // Compute mother safety & intersection
   //
   G4ThreeVector exitVectorMother;
   G4bool        exitConvex= false; // Value obtained in DistanceToOut(p,v) call
   G4ExitNormal  motherNormalStc;
 
   repPoint = history.GetTransform(depth).TransformPoint(globalPoint);
   motherPhysical = history.GetVolume(depth);
   motherSolid = motherPhysical->GetLogicalVolume()->GetSolid();
   motherSafety = motherSolid->DistanceToOut(repPoint);
   repDirection = history.GetTransform(depth).TransformAxis(globalDirection);
 
   motherStep = motherSolid->DistanceToOut(repPoint,repDirection,true,
                                           &exitConvex,&exitVectorMother);
   if( exitConvex )
   {
      motherNormalStc = G4ExitNormal( exitVectorMother, true, false,
                                      G4ExitNormal::kMother);
      calculatedExitNormal= true;
   }
   const G4AffineTransform& globalToLocalTop = history.GetTopTransform();
 
   G4bool motherDeterminedStep= (motherStep<ourStep);
 
   if( (!exitConvex) && motherDeterminedStep )
   {
      exitVectorMother= motherSolid->SurfaceNormal( repPoint );
      motherNormalStc= G4ExitNormal( exitVectorMother, true, false,
                                     G4ExitNormal::kMother);
      // CalculatedExitNormal -> true;
      // Convex               -> false: do not know value
      // ExitSide             -> kMother (or kNull)
  
      calculatedExitNormal= true;
   }
   if( motherDeterminedStep)
   {
      G4ThreeVector globalExitNormalTop=
         globalToLocalTop.Inverse().TransformAxis(exitVectorMother);
      
      exitNormalStc= motherNormalStc;
      exitNormalStc.exitNormal= globalExitNormalTop;
   }
 
   // Push in principle no longer necessary. G4Navigator now takes care of ...
   // Removing this however may cause additional almost-zero steps and generate
   // warnings for pushed particles from G4Navigator, particularly for the case
   // of 3D replicas (Cartesian or combined Radial/Phi cases).
   // Requires further investigation and eventually reimplementation of
   // LevelLocate() to take into account point and direction ...
   //
   if  ( ( (ourStep<fMinStep) && (sampleSafety<halfkCarTolerance) )
      && ( repLogical->GetSolid()->Inside(localPoint)==kSurface ) )
   {
     ourStep = 100*kCarTolerance;
   }
 
   if ( motherSafety<ourSafety )
   {
     ourSafety = motherSafety;
   }
 
 #ifdef G4VERBOSE
   if ( fCheck )
   {
     if( motherSolid->Inside(localPoint)==kOutside )
     {
       std::ostringstream message;
       message << "Point outside volume !" << G4endl
               << "          Point " << localPoint
               << " is outside current volume " << motherPhysical->GetName()
               << G4endl;
       G4double estDistToSolid= motherSolid->DistanceToIn(localPoint); 
       message << "          Estimated isotropic distance to solid (distToIn)= " 
               << estDistToSolid << G4endl;
       if( estDistToSolid > 100.0 * kCarTolerance )
       {
         motherSolid->DumpInfo();
         G4Exception("G4ReplicaNavigation::ComputeStep()",
                     "GeomNav0003", FatalException, message,
                     "Point is far outside Current Volume !" ); 
       }
       else
         G4Exception("G4ReplicaNavigation::ComputeStep()",
                     "GeomNav1002", JustWarning, message,
                     "Point is a little outside Current Volume."); 
     }
   }
 #endif
 
   // Comparison of steps may need precision protection
   //
 #if 1
   if( motherDeterminedStep)
   {
     ourStep = motherStep;
     exiting = true;
   }
 
   // Transform it to the Grand-Mother Reference Frame (current convention)
   //
   if ( calculatedExitNormal )
   {
     if ( motherDeterminedStep )
     {
       exitNormalVector= motherNormalStc.exitNormal;
     }
     else
     {
       G4ThreeVector exitNormalGlobal= exitNormalStc.exitNormal;
       exitNormalVector= globalToLocalTop.TransformAxis(exitNormalGlobal);
       // exitNormalVector= globalToLocal2nd.TransformAxis(exitNormalGlobal);
       // Alt Make it in one go to Grand-Mother, avoiding transform below
     }
     // Transform to Grand-mother reference frame
     const G4RotationMatrix* rot = motherPhysical->GetRotation();
     if ( rot )
     {
       exitNormalVector *= rot->inverse();
     }
 
   }
   else
   {
     validExitNormal = false;
   }
 
 #else
   if ( motherSafety<=ourStep )
   {
     if ( motherStep<=ourStep )
     {
       ourStep = motherStep;
       exiting = true;
       if ( validExitNormal )
       {
         const G4RotationMatrix* rot = motherPhysical->GetRotation();
         if ( rot )
         {
           exitNormal *= rot->inverse();
         }
       }
     }
     else
     {
       validExitNormal = false;
       // calculatedExitNormal= false;
     }
   }
 #endif
 
 
   G4bool daughterDeterminedStep=false;
   G4ThreeVector daughtNormRepCrd;
      // Exit normal of daughter transformed to
      // the coordinate system of Replica (i.e. last depth)
 
   //
   // Compute daughter safeties & intersections
   //
   localNoDaughters = repLogical->GetNoDaughters();
   for ( sampleNo=localNoDaughters-1; sampleNo>=0; sampleNo-- )
   {
     samplePhysical = repLogical->GetDaughter(sampleNo);
     if ( samplePhysical!=blockedExitedVol )
     {
       G4ThreeVector localExitNorm;
       G4ThreeVector normReplicaCoord;
 
       G4AffineTransform sampleTf(samplePhysical->GetRotation(),
                                  samplePhysical->GetTranslation());
       sampleTf.Invert();
       const G4ThreeVector samplePoint =
                         sampleTf.TransformPoint(localPoint);
       const G4VSolid* sampleSolid =
                         samplePhysical->GetLogicalVolume()->GetSolid();
       const G4double sampleSafetyDistance =
                         sampleSolid->DistanceToIn(samplePoint);
       if ( sampleSafetyDistance<ourSafety )
       {
         ourSafety = sampleSafetyDistance;
       }
       if ( sampleSafetyDistance<=ourStep )
       {
         sampleDirection = sampleTf.TransformAxis(localDirection);
         const G4double sampleStepDistance =
                         sampleSolid->DistanceToIn(samplePoint,sampleDirection);
         if ( sampleStepDistance<=ourStep )
         {
           daughterDeterminedStep= true;
 
           ourStep  = sampleStepDistance;
           entering = true;
           exiting  = false;
           *pBlockedPhysical = samplePhysical;
           blockedReplicaNo  = sampleNo;
 
 #ifdef DAUGHTER_NORMAL_ALSO
           // This norm can be calculated later, if needed daughter is available
           localExitNorm = sampleSolid->SurfaceNormal(samplePoint);
           daughtNormRepCrd = sampleTf.Inverse().TransformAxis(localExitNorm);
 #endif
           
 #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 ) && ( sampleStepDistance < kInfinity ) )
           {
             G4ThreeVector intersectionPoint;
             intersectionPoint= samplePoint
                              + sampleStepDistance * 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 DistanceToIn for solid "
                       << sampleSolid->GetName() << G4endl
                       << "          Solid gave DistanceToIn = "
                       << sampleStepDistance << " 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)
                        << G4endl;
               if ( insideIntPt != kOutside ) 
                 message << "        DistanceToOut(p) = " 
                        << sampleSolid->DistanceToOut(intersectionPoint);
               G4Exception("G4ReplicaNavigation::ComputeStep()", 
                           "GeomNav1002", JustWarning, message); 
               G4cout.precision(oldcoutPrec);
             }
           }
 #endif
         }
       }
     }
   }
 
   calculatedExitNormal &= (!daughterDeterminedStep);
 
 #ifdef DAUGHTER_NORMAL_ALSO
   if( daughterDeterminedStep )
   {
     // G4ThreeVector daughtNormGlobal =
     //   GlobalToLastDepth.Inverse().TransformAxis(daughtNormRepCrd);
     // ==> Can calculate it, but have no way to transmit it to caller (for now)
 
     exitNormalVector=globalToLocalTop.Inverse().TransformAxis(daughtNormGlobal);
     validExitNormal= false; // Entering daughter - never convex for parent
 
     calculatedExitNormal= true;
   }
   // calculatedExitNormal= true;  // Force it to true -- dubious
 #endif
 
   newSafety = ourSafety;
   return ourStep;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ReplicaNavigation::ComputeTransformation	(	const G4int	replicaNo,
		G4VPhysicalVolume *	pVol,
		G4ThreeVector &	point
	)		const

Definition at line 654 of file G4ReplicaNavigation.cc.

 {
   G4double val,cosv,sinv,tmpx,tmpy;
 
   // Replication data
   //
   EAxis axis;
   G4int nReplicas;
   G4double width,offset;
   G4bool consuming;
 
   pVol->GetReplicationData(axis, nReplicas, width, offset, consuming);
 
   switch (axis)
   {
     case kXAxis:
       val = -width*0.5*(nReplicas-1)+width*replicaNo;
       pVol->SetTranslation(G4ThreeVector(val,0,0));
       point.setX(point.x()-val);
       break;
     case kYAxis:
       val = -width*0.5*(nReplicas-1)+width*replicaNo;
       pVol->SetTranslation(G4ThreeVector(0,val,0));
       point.setY(point.y()-val);
       break;
     case kZAxis:
       val = -width*0.5*(nReplicas-1)+width*replicaNo;
       pVol->SetTranslation(G4ThreeVector(0,0,val));
       point.setZ(point.z()-val);
       break;
     case kPhi:
       val = -(offset+width*(replicaNo+0.5));
       SetPhiTransformation(val,pVol);
       cosv = std::cos(val);
       sinv = std::sin(val);
       tmpx = point.x()*cosv-point.y()*sinv;
       tmpy = point.x()*sinv+point.y()*cosv;
       point.setY(tmpy);
       point.setX(tmpx);
       break;
     case kRho:
       // No setup required for radial case
     default:
       break;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ReplicaNavigation::ComputeTransformation	(	const G4int	replicaNo,
		G4VPhysicalVolume *	pVol
	)		const

Definition at line 710 of file G4ReplicaNavigation.cc.

 {
   G4double val;
 
   // Replication data
   //
   EAxis axis;
   G4int nReplicas;
   G4double width, offset;
   G4bool consuming;
 
   pVol->GetReplicationData(axis, nReplicas, width, offset, consuming);
 
   switch (axis)
   {
     case kXAxis:
       val = -width*0.5*(nReplicas-1)+width*replicaNo;
       pVol->SetTranslation(G4ThreeVector(val,0,0));
       break;
     case kYAxis:
       val = -width*0.5*(nReplicas-1)+width*replicaNo;
       pVol->SetTranslation(G4ThreeVector(0,val,0));
       break;
     case kZAxis:
       val = -width*0.5*(nReplicas-1)+width*replicaNo;
       pVol->SetTranslation(G4ThreeVector(0,0,val));
       break;
     case kPhi:
       val = -(offset+width*(replicaNo+0.5));
       SetPhiTransformation(val,pVol);
       break;
     case kRho:
       // No setup required for radial case
     default:
       break;
   }
 }

Here is the call graph for this function:

G4double G4ReplicaNavigation::DistanceToOut	(	const G4VPhysicalVolume *	pVol,
		const G4int	replicaNo,
		const G4ThreeVector &	localPoint
	)		const

Definition at line 188 of file G4ReplicaNavigation.cc.

 {
   // Replication data
   //
   EAxis axis;
   G4int nReplicas;
   G4double width,offset;
   G4bool consuming;
   
   G4double safety=0.;
   G4double safe1,safe2;
   G4double coord, rho, rmin, rmax;
 
   pVol->GetReplicationData(axis, nReplicas, width, offset, consuming);
   switch(axis)
   {
     case kXAxis:
     case kYAxis:
     case kZAxis:
        coord = localPoint(axis);
        safe1 = width*0.5-coord;
        safe2 = width*0.5+coord;
        safety = (safe1<=safe2) ? safe1 : safe2;
        break;
     case kPhi:
       if ( localPoint.y()<=0 )
       {
         safety = localPoint.x()*std::sin(width*0.5)
                + localPoint.y()*std::cos(width*0.5);
       }
       else
       {
         safety = localPoint.x()*std::sin(width*0.5)
                - localPoint.y()*std::cos(width*0.5);
       }
       break;
     case kRho:
       rho = localPoint.perp();
       rmax = width*(replicaNo+1)+offset;
       if ( replicaNo||offset )
       {
         rmin  = rmax-width;
         safe1 = rho-rmin;
         safe2 = rmax-rho;
         safety = (safe1<=safe2) ? safe1 : safe2;
       }
       else
       {
         safety = rmax-rho;
       }
       break;
     default:
      G4Exception("G4ReplicaNavigation::DistanceToOut()", "GeomNav0002",
                  FatalException, "Unknown axis!");
      break;
   }
   return (safety >= halfkCarTolerance) ? safety : 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4ReplicaNavigation::DistanceToOut	(	const G4VPhysicalVolume *	pVol,
		const G4int	replicaNo,
		const G4ThreeVector &	localPoint,
		const G4ThreeVector &	localDirection,
		G4ExitNormal &	candidateNormal
	)		const

Definition at line 254 of file G4ReplicaNavigation.cc.

 {
   // Replication data
   //
   EAxis axis;
   G4int nReplicas;
   G4double width, offset;
   G4bool consuming;
 
   G4double Dist=kInfinity;
   G4double coord, Comp, lindist;
   G4double signC = 0.0;
   G4ExitNormal candidateNormal; 
    
   pVol->GetReplicationData(axis, nReplicas, width, offset, consuming);
   switch(axis)
   {
     case kXAxis:
     case kYAxis:
     case kZAxis:
       coord = localPoint(axis);
       Comp = localDirection(axis);
       if ( Comp>0 )
       {
         lindist = width*0.5-coord;
         Dist = (lindist>0) ? lindist/Comp : 0;
         signC= 1.0;
       }
       else if ( Comp<0 )
       {
         lindist = width*0.5+coord;
         Dist = (lindist>0) ? -lindist/Comp : 0;
         signC= -1.0;
       }
       else
       {
         Dist = kInfinity;
       }
       // signC = sign<G4double>(Comp)
       candidateNormal.exitNormal = ( signC * VecCartAxes[axis]);
       candidateNormal.calculated = true;
       candidateNormal.validConvex = true;
       candidateNormal.exitSide =
         (Comp>0) ? SideCartAxesPlus[axis] : SideCartAxesMinus[axis];
       break;
     case kPhi:
       Dist = DistanceToOutPhi(localPoint,localDirection,width,candidateNormal);
         // candidateNormal set in call
       break;
     case kRho:
       Dist = DistanceToOutRad(localPoint,localDirection,width,offset,
                               replicaNo,candidateNormal);
         // candidateNormal set in call
       break;
     default:
      G4Exception("G4ReplicaNavigation::DistanceToOut()", "GeomNav0002",
                  FatalException, "Unknown axis!");
      break;
   }
 
   arExitNormal= candidateNormal; // .exitNormal;
 
   return Dist;
 }

Here is the call graph for this function:

G4int G4ReplicaNavigation::GetVerboseLevel ( ) const

inline

EInside G4ReplicaNavigation::Inside	(	const G4VPhysicalVolume *	pVol,
		const G4int	replicaNo,
		const G4ThreeVector &	localPoint
	)		const

Definition at line 82 of file G4ReplicaNavigation.cc.

 {
   EInside in = kOutside;
   
   // Replication data
   //
   EAxis axis;
   G4int nReplicas;
   G4double width, offset;
   G4bool consuming;
   
   G4double coord, rad2, rmin, tolRMax2, rmax, tolRMin2;
 
   pVol->GetReplicationData(axis, nReplicas, width, offset, consuming);
 
   switch (axis)
   {
     case kXAxis:
     case kYAxis:
     case kZAxis:
       coord = std::fabs(localPoint(axis))-width*0.5;
       if ( coord<=-halfkCarTolerance )
       {
         in = kInside;
       }
       else if ( coord<=halfkCarTolerance )
       {
         in = kSurface;
       }
       break;
     case kPhi:
       if ( localPoint.y()||localPoint.x() )
       {
         coord = std::fabs(std::atan2(localPoint.y(),localPoint.x()))-width*0.5;
         if ( coord<=-halfkAngTolerance )
         {
           in = kInside;
         }
         else if ( coord<=halfkAngTolerance )
         {
           in = kSurface;
         }
       }
       else
       {
         in = kSurface;
       }
       break;
     case kRho:
       rad2 = localPoint.perp2();
       rmax = (replicaNo+1)*width+offset;
       tolRMax2  = rmax-halfkRadTolerance;
       tolRMax2 *= tolRMax2;
       if ( rad2>tolRMax2 )
       {
         tolRMax2 = rmax+halfkRadTolerance;
         tolRMax2 *= tolRMax2;
         if ( rad2<=tolRMax2 )
         {
           in = kSurface;
         }
       }
       else
       {
         // Known to be inside outer radius
         //
         if ( replicaNo||offset )
         {
           rmin = rmax-width;
           tolRMin2 = rmin-halfkRadTolerance;
           tolRMin2 *= tolRMin2;
           if ( rad2>tolRMin2 )
           {
             tolRMin2 = rmin+halfkRadTolerance;
             tolRMin2 *= tolRMin2;
             if ( rad2>=tolRMin2 )
             {
               in = kInside;
             }
             else
             {
               in = kSurface;
             }
           }
         }
         else
         {
           in = kInside;
         }
       }
       break;
     default:
       G4Exception("G4ReplicaNavigation::Inside()", "GeomNav0002",
                   FatalException, "Unknown axis!");
       break;
   }
   return in;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Here is the caller graph for this function:

void G4ReplicaNavigation::SetVerboseLevel ( G4int level )

inline

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

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation