G4SphericalSurface Class Reference

#include <G4SphericalSurface.hh>

Inheritance diagram for G4SphericalSurface:

Public Member Functions
	G4SphericalSurface ()
	G4SphericalSurface (const G4Vector3D &o, const G4Vector3D &xhat, const G4Vector3D &zhat, G4double r, G4double ph1, G4double ph2, G4double th1, G4double th2)
virtual	~G4SphericalSurface ()
G4int	operator== (const G4SphericalSurface &s)
G4String	GetEntityType () const
virtual const char *	NameOf () const
virtual void	PrintOn (std::ostream &os=G4cout) const
G4int	Intersect (const G4Ray &)
void	CalcBBox ()
void	Comp (G4Vector3D &v, G4Point3D &min, G4Point3D &max)
virtual G4double	HowNear (const G4Vector3D &x) const
virtual G4Vector3D	SurfaceNormal (const G4Point3D &p) const
virtual G4int	Inside (const G4Vector3D &x) const
virtual G4int	WithinBoundary (const G4Vector3D &x) const
virtual G4double	Scale () const
virtual G4double	Area () const
virtual void	resize (G4double r, G4double ph1, G4double ph2, G4double th1, G4double th2)
G4Vector3D	GetXAxis () const
G4Vector3D	GetZAxis () const
G4double	GetRadius () const
G4double	GetPhi1 () const
G4double	GetPhi2 () const
G4double	GetTheta1 () const
G4double	GetTheta2 () const
virtual G4Vector3D	Normal (const G4Vector3D &p) const
Protected Attributes
G4Vector3D	x_axis
G4Vector3D	z_axis
G4double	radius
G4double	phi_1
G4double	phi_2
G4double	theta_1
G4double	theta_2

---

Detailed Description

Definition at line 49 of file G4SphericalSurface.hh.

---

Constructor & Destructor Documentation

G4SphericalSurface::G4SphericalSurface

(

)

Definition at line 39 of file G4SphericalSurface.cc.

References x_axis, and z_axis.

  : G4Surface(), radius(1.0), phi_1(0.0), phi_2(2*pi),
    theta_1(0.0), theta_2(pi)
{
   // default constructor
   // default x_axis is ( 1.0, 0.0, 0.0 ), z_axis is ( 0.0, 0.0, 1.0 ),
   // default radius is 1.0
   // default phi_1 is 0, phi_2 is 2*PI
   // default theta_1 is 0, theta_2 is PI

   x_axis = G4Vector3D( 1.0, 0.0, 0.0 );
   z_axis = G4Vector3D( 0.0, 0.0, 1.0 );
   //   OuterBoundary = new G4BREPPolyline();
}

G4SphericalSurface::G4SphericalSurface	(	const G4Vector3D &	o,
		const G4Vector3D &	xhat,
		const G4Vector3D &	zhat,
		G4double	r,
		G4double	ph1,
		G4double	ph2,
		G4double	th1,
		G4double	th2
	)

Definition at line 55 of file G4SphericalSurface.cc.

References G4endl, G4Exception(), JustWarning, phi_1, phi_2, G4INCL::Math::pi, radius, theta_1, theta_2, x_axis, and z_axis.

  : G4Surface()
{ 
  // Require both x_axis and z_axis to be unit vectors

  G4double xhatmag = xhat.mag();
  if ( xhatmag != 0.0 )
  {
    x_axis = xhat * (1/ xhatmag); // this makes the x_axis a unit vector
  }
  else
  {
    std::ostringstream message;
    message << "x_axis has zero length." << G4endl
            << "Default x_axis of (1, 0, 0) is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    x_axis = G4Vector3D( 1.0, 0.0, 0.0 );
  }

  G4double zhatmag = zhat.mag();
  
  if (zhatmag != 0.0)
  {
    z_axis = zhat *(1/ zhatmag);  // this makes the z_axis a unit vector
  }
  else 
  {
    std::ostringstream message;
    message << "z_axis has zero length." << G4endl
            << "Default z_axis of (0, 0, 1) is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    z_axis = G4Vector3D( 0.0, 0.0, 1.0 );
  }
  
  //  Require radius to be non-negative
  //
  if ( r >= 0.0 )
  {
    radius = r;
  }
  else 
  {
    std::ostringstream message;
    message << "Radius cannot be less than zero." << G4endl
            << "Default radius of 1.0 is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    radius = 1.0;
  }

  //  Require phi_1 in the range: 0 <= phi_1 < 2*PI
  //  and phi_2 in the range: phi_1 < phi_2 <= phi_1 + 2*PI
  //
  if ( ( ph1 >= 0.0 ) && ( ph1 < 2*pi ) )
  {
    phi_1 = ph1;
  }
  else 
  {
    std::ostringstream message;
    message << "Lower azimuthal limit is out of range." << G4endl
            << "Default angle of 0 is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    phi_1 = 0.0;
  }

  if ( ( ph2 > phi_1 ) && ( ph2 <=  ( phi_1 + twopi ) ) )
  {
    phi_2 = ph2;
  }
  else 
  {
    std::ostringstream message;
    message << "Upper azimuthal limit is out of range." << G4endl
            << "Default angle of 2*PI is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    phi_2 = twopi;
  }
 
  //  Require theta_1 in the range: 0 <= theta_1 < PI 
  //  and theta-2 in the range: theta_1 < theta_2 <= theta_1 + PI
  //
  if ( ( th1 >= 0.0 ) && ( th1 < pi ) )
  {
    theta_1 = th1;
  }
  else
  {
    std::ostringstream message;
    message << "Lower polar limit is out of range." << G4endl
            << "Default angle of 0 is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    theta_1 = 0.0;
  }  
  
  if  ( ( th2 > theta_1 ) && ( th2 <= ( theta_1 + pi ) ) )
  {
    theta_2 =th2;
  }
  else 
  {
    std::ostringstream message;
    message << "Upper polar limit is out of range." << G4endl
            << "Default angle of PI is used.";    
    G4Exception("G4SphericalSurface::G4SphericalSurface()",
                "GeomSolids1001", JustWarning, message);

    theta_2 = pi;
  } 
}

G4SphericalSurface::~G4SphericalSurface

(

)

[virtual]

Definition at line 183 of file G4SphericalSurface.cc.

{
}

---

Member Function Documentation

G4double G4SphericalSurface::Area

(

)

const [virtual]

Definition at line 831 of file G4SphericalSurface.cc.

References phi_1, phi_2, G4INCL::Math::pi, radius, theta_1, and theta_2.

{
  // Returns the Area of a G4SphericalSurface

  return ( 2.0*( theta_2 - theta_1 )*( phi_2 - phi_1)*radius*radius/pi );
}

void G4SphericalSurface::CalcBBox

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 337 of file G4SphericalSurface.cc.

References G4Surface::bbox, G4Surface::origin, and radius.

{
  G4double x_min = origin.x() - radius;
  G4double y_min = origin.y() - radius;
  G4double z_min = origin.z() - radius;
  G4double x_max = origin.x() + radius;
  G4double y_max = origin.y() + radius;
  G4double z_max = origin.z() + radius;  
    
  G4Point3D Min(x_min, y_min, z_min);
  G4Point3D Max(x_max, y_max, z_max);  
  bbox = new G4BoundingBox3D( Min, Max); 
}

void G4SphericalSurface::Comp	(	G4Vector3D &	v,
		G4Point3D &	min,
		G4Point3D &	max
	)			[inline]

Definition at line 57 of file G4SphericalSurface.icc.

{
  if(v.x() > max.x()) max.setX(v.x());
  if(v.y() > max.y()) max.setY(v.y());
  if(v.z() > max.z()) max.setZ(v.z());

  if(v.x() < min.x()) min.setX(v.x());
  if(v.y() < min.y()) min.setY(v.y());
  if(v.z() < min.z()) min.setZ(v.z());
}

G4String G4SphericalSurface::GetEntityType

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 51 of file G4SphericalSurface.icc.

{
  return G4String("Spherical_Surface");
}

G4double G4SphericalSurface::GetPhi1

(

)

const [inline]

Definition at line 87 of file G4SphericalSurface.icc.

References phi_1.

{
  return phi_1;
}

G4double G4SphericalSurface::GetPhi2

(

)

const [inline]

Definition at line 93 of file G4SphericalSurface.icc.

References phi_2.

{
  return phi_2;
}

G4double G4SphericalSurface::GetRadius

(

)

const [inline]

Definition at line 81 of file G4SphericalSurface.icc.

References radius.

Referenced by Intersect().

{
  return radius;
}

G4double G4SphericalSurface::GetTheta1

(

)

const [inline]

Definition at line 99 of file G4SphericalSurface.icc.

References theta_1.

{
  return theta_1;
}

G4double G4SphericalSurface::GetTheta2

(

)

const [inline]

Definition at line 105 of file G4SphericalSurface.icc.

References theta_2.

{
  return theta_2;
}

G4Vector3D G4SphericalSurface::GetXAxis

(

)

const [inline]

Definition at line 69 of file G4SphericalSurface.icc.

References x_axis.

{
  return x_axis;
}

G4Vector3D G4SphericalSurface::GetZAxis

(

)

const [inline]

Definition at line 75 of file G4SphericalSurface.icc.

References z_axis.

{
  return z_axis;
}

G4double G4SphericalSurface::HowNear

(

const G4Vector3D &

x

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 233 of file G4SphericalSurface.cc.

References G4Surface::origin, and radius.

Referenced by Inside(), and Intersect().

{
  //  Distance from the point x to the G4SphericalSurface.
  //  The distance will be positive if the point is Inside the 
  //  G4SphericalSurface, negative if the point is outside.

  G4Vector3D d = G4Vector3D( x - origin );
  G4double rds = d.mag();

  return (radius - rds);
}

G4int G4SphericalSurface::Inside

(

const G4Vector3D &

x

)

const [virtual]

Definition at line 756 of file G4SphericalSurface.cc.

References HowNear().

{
  // Return 0 if point x is outside G4SphericalSurface, 1 if Inside.
  // Outside means that the distance to the G4SphericalSurface would 
  // be negative.
  // Use the HowNear function to calculate this distance.

  if ( HowNear( x ) >= 0.0 )  { return 1; }
  else                        { return 0; }
}

G4int G4SphericalSurface::Intersect

(

const G4Ray &

)

[virtual]

Reimplemented from G4Surface.

Definition at line 352 of file G4SphericalSurface.cc.

References G4Surface::closest_hit, G4Surface::distance, G4Ray::GetDir(), G4Surface::GetOrigin(), G4Ray::GetPoint(), GetRadius(), G4Ray::GetStart(), HowNear(), G4Surface::kCarTolerance, Normal(), and WithinBoundary().

{
  //  Distance along a Ray (straight line with G4Vector3D) to leave or enter
  //  a G4SphericalSurface.  The input variable which_way should be set to +1 
  //  to indicate leaving a G4SphericalSurface, -1 to indicate entering a 
  //  G4SphericalSurface.
  //  p is the point of intersection of the Ray with the G4SphericalSurface.
  //  If the G4Vector3D of the Ray is opposite to that of the Normal to
  //  the G4SphericalSurface at the intersection point, it will not leave the
  //  G4SphericalSurface.
  //  Similarly, if the G4Vector3D of the Ray is along that of the Normal 
  //  to the G4SphericalSurface at the intersection point, it will not enter 
  //  the G4SphericalSurface.
  //  This method is called by all finite shapes sub-classed to 
  //  G4SphericalSurface.
  //  Use the virtual function table to check if the intersection point
  //  is within the boundary of the finite shape.
  //  A negative result means no intersection.
  //  If no valid intersection point is found, set the distance
  //  and intersection point to large numbers.

  G4int which_way = (G4int)HowNear(ry.GetStart());
  
  if(!which_way)  { which_way =-1; }
  distance = kInfinity;
  
  G4Vector3D lv ( kInfinity, kInfinity, kInfinity );

  // p = lv;
  //
  closest_hit = lv;

  // Origin and G4Vector3D unit vector of Ray.
  //
  G4Vector3D x= G4Vector3D( ry.GetStart() );
  G4Vector3D dhat = ry.GetDir();
  G4int isoln = 0, maxsoln = 2;

  // Array of solutions in distance along the Ray
  //
  G4double ss[2];
  ss[0] = -1.0 ; 
  ss[1] = -1.0 ;

  // Calculate the two solutions (quadratic equation)
  //
  G4Vector3D d = G4Vector3D( x - GetOrigin() );
  G4double r = GetRadius();

  // Quit with no intersection if the radius of the G4SphericalSurface is zero
  //
  if ( r <= 0.0 )  { return 0; }
  
  G4double dsq     = d * d;
  G4double rsq     = r * r;
  G4double b       = d * dhat;
  G4double c       = dsq - rsq;
  G4double radical = b * b - c;
  
  // Quit with no intersection if the radical is negative
  //
  if ( radical < 0.0 )  { return 0; }
  
  G4double root = std::sqrt( radical );
  ss[0] = -b + root;
  ss[1] = -b - root;

  // Order the possible solutions by increasing distance along the Ray
  // G4Sort_double( ss, isoln, maxsoln-1 );
  //        
  if(ss[0] > ss[1])
  {
    G4double tmp =ss[0];
    ss[0] = ss[1];
    ss[1] = tmp;
  }

  // Now loop over each positive solution, keeping the first one (smallest
  // distance along the Ray) which is within the boundary of the sub-shape
  // and which also has the correct G4Vector3D with respect to the Normal to
  // the G4SphericalSurface at the intersection point
  //
  for ( isoln = 0; isoln < maxsoln; isoln++ ) 
  {
    if ( ss[isoln] >= kCarTolerance*0.5 ) 
    {
      if ( ss[isoln] >= kInfinity )  { return 0; }  // quit if too large
      distance = ss[isoln];
      closest_hit = ry.GetPoint( distance );
      if ( ( ( dhat * Normal( closest_hit ) * which_way ) >= 0.0 ) && 
           ( WithinBoundary( closest_hit ) == 1 )                      )
      {
        distance =  distance*distance;    
        return 1;
      }
    }
  }
  
  // Get here only if there was no solution within the boundary,
  // reset distance and intersection point to large numbers
  //
  distance = kInfinity;
  closest_hit = lv;

  return 0;
}          

const char * G4SphericalSurface::NameOf

(

)

const [virtual]

Definition at line 215 of file G4SphericalSurface.cc.

{
  return "G4SphericalSurface";
}

G4Vector3D G4SphericalSurface::Normal

(

const G4Vector3D &

p

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 720 of file G4SphericalSurface.cc.

References CLHEP::detail::n, and G4Surface::origin.

Referenced by Intersect().

{ 
  // Return the Normal unit vector to the G4SphericalSurface at a point p on
  // (or nearly on) the G4SphericalSurface.

  G4Vector3D n = G4Vector3D( p - origin );
  G4double nmag = n.mag();
  
  //  If the point p happens to coincide with the origin (which is possible
  //  if the radius is zero), set the Normal to the z-axis unit vector.
  //
  if ( nmag != 0.0 )  { n = n * (1/ nmag); }
  else  { n = G4Vector3D( 0.0, 0.0, 1.0 ); }

  return n;
}

G4int G4SphericalSurface::operator==

(

const G4SphericalSurface &

s

)

[inline]

Definition at line 38 of file G4SphericalSurface.icc.

References G4Surface::origin, phi_1, phi_2, radius, theta_1, theta_2, x_axis, and z_axis.

{
  return origin  == surf.origin  &&  
  x_axis  == surf.x_axis  &&
  z_axis  == surf.z_axis  &&
  radius  == surf.radius  && 
  phi_1   == surf.phi_1   &&
  phi_2   == surf.phi_2   &&
  theta_1 == surf.theta_1 &&
  theta_2 == surf.theta_2;
}   

void G4SphericalSurface::PrintOn

(

std::ostream &

os = G4cout

)

const [virtual]

Definition at line 220 of file G4SphericalSurface.cc.

References G4Surface::origin, phi_1, phi_2, radius, theta_1, theta_2, x_axis, and z_axis.

{  
  os << "G4SphericalSurface surface with origin: " << origin << "\t"
     << "radius: " << radius << "\n"
     << "\t local x_axis: " << x_axis
     << "\t local z_axis: " << z_axis << "\n" 
     << "\t lower azimuthal limit: " << phi_1 << " radians\n"
     << "\t upper azimuthal limit: " << phi_2 << " radians\n"
     << "\t lower polar limit    : " << theta_1 << " radians\n"
     << "\t upper polar limit    : " << theta_2 << " radians\n";
}

void G4SphericalSurface::resize	(	G4double	r,
		G4double	ph1,
		G4double	ph2,
		G4double	th1,
		G4double	th2
	)			[virtual]

Definition at line 839 of file G4SphericalSurface.cc.

References G4endl, G4Exception(), JustWarning, G4Surface::kAngTolerance, phi_1, phi_2, G4INCL::Math::pi, radius, theta_1, and theta_2.

{ 
  // Resize the G4SphericalSurface to new radius r, new lower and upper 
  // azimuthal angle limits ph1 and ph2, and new lower and upper polar 
  // angle limits th1 and th2.
  
  //  Require radius to be non-negative
  //
  if ( r >= 0.0 )  { radius = r; }
  else 
  {
    std::ostringstream message;
    message << "Radius cannot be less than zero." << G4endl
            << "Original value of " << radius << " is retained.";    
    G4Exception("G4SphericalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }

  //  Require azimuthal angles to be within bounds
  
  if ( ( ph1 >= 0.0 ) && ( ph1 < twopi ) )  { phi_1 = ph1; }
  else 
  {
    std::ostringstream message;
    message << "Lower azimuthal limit out of range." << G4endl
            << "Original value of " << phi_1 << " is retained.";    
    G4Exception("G4SphericalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
  
  if ( ( ph2 > phi_1 ) && ( ph2 <= ( phi_1 + twopi ) ) )  { phi_2 = ph2; }
  else 
  {
    ph2 = ( phi_2 <= phi_1 ) ? ( phi_1 + kAngTolerance ) : phi_2;
    phi_2 = ph2;
    std::ostringstream message;
    message << "Upper azimuthal limit out of range." << G4endl
            << "Value of " << phi_2 << " is used.";    
    G4Exception("G4SphericalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }

  // Require polar angles to be within bounds
  //
  if ( ( th1 >= 0.0 ) && ( th1 < pi ) )  { theta_1 = th1; }
  else 
  {
    std::ostringstream message;
    message << "Lower polar limit out of range." << G4endl
            << "Original value of " << theta_1 << " is retained.";    
    G4Exception("G4SphericalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
  
  if ( ( th2 > theta_1 ) && ( th2 <= ( theta_1 + pi ) ) )  { theta_2 = th2; }
  else
  {
    th2 = ( theta_2 <= theta_1 ) ? ( theta_1 + kAngTolerance ) : theta_2;
    theta_2 = th2;
    std::ostringstream message;
    message << "Upper polar limit out of range." << G4endl
            << "Value of " << theta_2 << " is used.";    
    G4Exception("G4SphericalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
}

G4double G4SphericalSurface::Scale

(

)

const [virtual]

Definition at line 820 of file G4SphericalSurface.cc.

References radius.

{
  // Returns the radius of a G4SphericalSurface unless it is zero, in which
  // case returns the arbitrary number 1.0.
  // Used for Scale-invariant tests of surface thickness.

  if ( radius == 0.0 )  { return 1.0; }
  else                  { return radius; }
}

G4Vector3D G4SphericalSurface::SurfaceNormal

(

const G4Point3D &

p

)

const [virtual]

Implements G4Surface.

Definition at line 738 of file G4SphericalSurface.cc.

References CLHEP::detail::n, and G4Surface::origin.

{ 
  // Return the Normal unit vector to the G4SphericalSurface at a point p on
  // (or nearly on) the G4SphericalSurface.

  G4Vector3D n = G4Vector3D( p - origin );
  G4double nmag = n.mag();
  
  //  If the point p happens to coincide with the origin (which is possible
  //  if the radius is zero), set the Normal to the z-axis unit vector.
  //
  if ( nmag != 0.0 )  { n = n * (1/ nmag); }
  else  { n = G4Vector3D( 0.0, 0.0, 1.0 ); }

  return n;
}

G4int G4SphericalSurface::WithinBoundary

(

const G4Vector3D &

x

)

const [virtual]

Definition at line 768 of file G4SphericalSurface.cc.

References phi_1, phi_2, G4INCL::Math::pi, theta_1, theta_2, x_axis, and z_axis.

Referenced by Intersect().

{ 
  // Return 1 if point x is on the G4SphericalSurface, otherwise return zero
  // (x is assumed to lie on the surface of the G4SphericalSurface, so one 
  // only checks the angular limits)

  G4Vector3D y_axis = G4Vector3D( z_axis.cross( x_axis ) );

  // Components of x in the local coordinate system of the G4SphericalSurface
  //
  G4double px = x * x_axis;
  G4double py = x * y_axis;
  G4double pz = x * z_axis;

  // Check if within polar angle limits
  //
  G4double theta = std::acos( pz / x.mag() );  // acos in range 0 to PI
  
  // Normal case
  //
  if ( theta_2 <= pi ) 
  {
    if ( ( theta < theta_1 ) || ( theta > theta_2 ) )  { return 0; }
  }
  else 
  {
    theta += pi;
    if ( ( theta < theta_1 ) || ( theta > theta_2 ) )  { return 0; }
  }

  // Now check if within azimuthal angle limits
  //
  G4double phi = std::atan2( py, px );  // atan2 in range -PI to PI
  
  if ( phi < 0.0 )  { phi += twopi; }
  
  // Normal case
  //
  if ( ( phi >= phi_1 )  &&  ( phi <= phi_2 ) )  { return 1; }
  
  // This is for the case that phi_2 is greater than 2*PI
  //
  phi += twopi;
  
  if ( ( phi >= phi_1 )  &&  ( phi <= phi_2 ) )  { return 1; }

  // Get here if not within azimuthal limits
 
  return 0;
}

---

Field Documentation

G4double G4SphericalSurface::phi_1 [protected]

Definition at line 213 of file G4SphericalSurface.hh.

Referenced by Area(), G4SphericalSurface(), GetPhi1(), operator==(), PrintOn(), resize(), and WithinBoundary().

G4double G4SphericalSurface::phi_2 [protected]

Definition at line 217 of file G4SphericalSurface.hh.

Referenced by Area(), G4SphericalSurface(), GetPhi2(), operator==(), PrintOn(), resize(), and WithinBoundary().

G4double G4SphericalSurface::radius [protected]

Definition at line 210 of file G4SphericalSurface.hh.

Referenced by Area(), CalcBBox(), G4SphericalSurface(), GetRadius(), HowNear(), operator==(), PrintOn(), resize(), and Scale().

G4double G4SphericalSurface::theta_1 [protected]

Definition at line 221 of file G4SphericalSurface.hh.

Referenced by Area(), G4SphericalSurface(), GetTheta1(), operator==(), PrintOn(), resize(), and WithinBoundary().

G4double G4SphericalSurface::theta_2 [protected]

Definition at line 225 of file G4SphericalSurface.hh.

Referenced by Area(), G4SphericalSurface(), GetTheta2(), operator==(), PrintOn(), resize(), and WithinBoundary().

G4Vector3D G4SphericalSurface::x_axis [protected]

Definition at line 202 of file G4SphericalSurface.hh.

Referenced by G4SphericalSurface(), GetXAxis(), operator==(), PrintOn(), and WithinBoundary().

G4Vector3D G4SphericalSurface::z_axis [protected]

Definition at line 206 of file G4SphericalSurface.hh.

Referenced by G4SphericalSurface(), GetZAxis(), operator==(), PrintOn(), and WithinBoundary().

---

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

• G4SphericalSurface.hh
• G4SphericalSurface.icc
• G4SphericalSurface.cc

---