G4ReplicaNavigation Class Reference

#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, const G4NavigationHistory &history, const G4double pProposedMaxLength=DBL_MAX) const
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 78 of file G4ReplicaNavigation.hh.

Constructor & Destructor Documentation

G4ReplicaNavigation()

G4ReplicaNavigation::G4ReplicaNavigation

(

)

Definition at line 53 of file G4ReplicaNavigation.cc.

{
  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;
}

~G4ReplicaNavigation()

G4ReplicaNavigation::~G4ReplicaNavigation ( )

default

Member Function Documentation

BackLocate()

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

Definition at line 1244 of file G4ReplicaNavigation.cc.

{
  G4VPhysicalVolume *pNRMother = nullptr;
  G4VSolid *motherSolid;
  G4ThreeVector repPoint, goodPoint;
  G4int mdepth, depth, cdepth;
  EInside insideCode;
 
  cdepth = (G4int)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 == nullptr ) 
  {
    // 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;
      }
      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;
}

Referenced by G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), and G4Navigator::LocateGlobalPointAndSetup().

CheckMode()

void G4ReplicaNavigation::CheckMode ( G4bool mode )

inline

ComputeSafety()

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

Definition at line 1155 of file G4ReplicaNavigation.cc.

{
  G4VPhysicalVolume *repPhysical, *motherPhysical;
  G4VPhysicalVolume *samplePhysical, *blockedExitedVol = nullptr;
  G4LogicalVolume *repLogical;
  G4VSolid *motherSolid;
  G4ThreeVector repPoint;
  G4double ourSafety = kInfinity;
  G4double sampleSafety;
  G4long 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 = (G4int)history.GetDepth()-1;
 
  // Loop checking, 07.10.2016, JA -- 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((G4int)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;
}

Referenced by G4ITNavigator1::ComputeSafety(), G4ITNavigator2::ComputeSafety(), and G4SafetyCalculator::SafetyInCurrentVolume().

ComputeStep()

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 747 of file G4ReplicaNavigation.cc.

{
  G4VPhysicalVolume *repPhysical, *motherPhysical;
  G4VPhysicalVolume *samplePhysical, *blockedExitedVol = nullptr;
  G4LogicalVolume *repLogical;
  G4VSolid *motherSolid;
  G4ThreeVector repPoint, repDirection, sampleDirection;
  G4double ourStep=currentProposedStepLength;
  G4double ourSafety=kInfinity;
  G4double sampleStep, sampleSafety, motherStep, motherSafety;
  G4long 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 auto  topDepth= (G4int)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().InverseTransformAxis(normalOutStc.exitNormal);
      calculatedExitNormal = true;
    }
  }
  const G4int secondDepth = topDepth;
  depth = secondDepth;  
 
  // Loop checking, 07.10.2016, JA -- 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.InverseTransformAxis(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.InverseTransformAxis(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 )
  {
    ourStep = 2*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 != nullptr )
    {
      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((G4int)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  = (G4int)sampleNo;
 
#ifdef DAUGHTER_NORMAL_ALSO
          // This norm can be calculated later, if needed daughter is available
          localExitNorm = sampleSolid->SurfaceNormal(samplePoint);
          daughtNormRepCrd = sampleTf.InverseTransformAxis(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 )
            {
              G4long 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.InverseTransformAxis(daughtNormGlobal);
    validExitNormal = false; // Entering daughter - never convex for parent
 
    calculatedExitNormal = true;
  }
  // calculatedExitNormal= true;  // Force it to true -- dubious
#endif
 
  newSafety = ourSafety;
  return ourStep;
}

Referenced by G4ITNavigator1::ComputeStep(), G4ITNavigator2::ComputeStep(), and G4Navigator::ComputeStep().

ComputeTransformation() [1/2]

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

Definition at line 703 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;
  }
}

ComputeTransformation() [2/2]

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

Definition at line 647 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;
  }
}

Referenced by G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4ITNavigator1::SetupHierarchy(), G4ITNavigator2::SetupHierarchy(), and G4Navigator::SetupHierarchy().

DistanceToOut() [1/2]

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

Definition at line 181 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 != 0)||(offset != 0.0) )
      {
        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;
}

Referenced by ComputeSafety(), and ComputeStep().

DistanceToOut() [2/2]

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

Definition at line 247 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;
}

GetVerboseLevel()

G4int G4ReplicaNavigation::GetVerboseLevel ( ) const

inline

Inside()

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

Definition at line 75 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() != 0.0)||(localPoint.x() != 0.0) )
      {
        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 != 0)||(offset != 0.0) )
        {
          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;
}

Referenced by BackLocate().

LevelLocate()

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

inline

Referenced by G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), and G4Navigator::LocateGlobalPointAndSetup().

SetVerboseLevel()

void G4ReplicaNavigation::SetVerboseLevel ( G4int level )

inline

---

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

• G4ReplicaNavigation.hh
• G4ReplicaNavigation.cc