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
Public Member Functions inherited from G4Surface
	G4Surface ()
virtual	~G4Surface ()
G4int	operator== (const G4Surface &s)
virtual G4String	GetEntityType () const
virtual const char *	Name () const
virtual G4int	MyType () const
void	SetBoundaries (G4CurveVector *)
virtual G4double	HowNear (const G4Vector3D &x) const
virtual G4double	ClosestDistanceToPoint (const G4Point3D &Pt)
G4Vector3D	GetOrigin () const
G4double	GetDistance () const
void	SetDistance (G4double Dist)
G4int	IsActive () const
void	SetActive (G4int act)
void	Deactivate ()
void	SetSameSense (G4int sameSense0)
G4int	GetSameSense () const
G4BoundingBox3D *	GetBBox ()
const G4Point3D &	GetClosestHit () const
void	SetNextNode (G4Surface *)
G4Surface *	GetNextNode ()
virtual void	Reset ()
virtual G4int	Intersect (const G4Ray &)
virtual G4Vector3D	Normal (const G4Vector3D &p) const
virtual void	CalcBBox ()
virtual G4double	GetUHit () const
virtual G4double	GetVHit () const
virtual G4Point3D	Evaluation (const G4Ray &G4Rayref)
virtual G4int	Evaluate (register const G4Ray &Rayref)
virtual void	Project ()
virtual void	CalcNormal ()
virtual G4int	IsConvex () const
virtual G4int	GetConvex () const
virtual G4int	GetNumberOfPoints () const
virtual const G4Point3D &	GetPoint (G4int Count) const
virtual G4Ray *	Norm ()
virtual G4Vector3D	SurfaceNormal (const G4Point3D &Pt) const =0
Public Member Functions inherited from G4STEPEntity
	G4STEPEntity ()
virtual	~G4STEPEntity ()
virtual G4String	GetEntityType () const =0

Protected Attributes
G4Vector3D	x_axis
G4Vector3D	z_axis
G4double	radius
G4double	phi_1
G4double	phi_2
G4double	theta_1
G4double	theta_2
Protected Attributes inherited from G4Surface
G4BoundingBox3D *	bbox
G4Point3D	closest_hit
G4Surface *	next
G4SurfaceBoundary	surfaceBoundary
G4double	kCarTolerance
G4double	kAngTolerance
G4int	Intersected
G4Vector3D	origin
G4int	Type
G4int	AdvancedFace
G4int	active
G4double	distance
G4double	uhit
G4double	vhit
G4int	sameSense

Additional Inherited Members
Static Public Member Functions inherited from G4Surface
static void	Project (G4double &Coord, const G4Point3D &Pt, const G4Plane &Pl)
Protected Member Functions inherited from G4Surface
virtual void	InitBounded ()

Detailed Description

Definition at line 49 of file G4SphericalSurface.hh.

Constructor & Destructor Documentation

G4SphericalSurface() [1/2]

G4SphericalSurface::G4SphericalSurface

(

)

Definition at line 39 of file G4SphericalSurface.cc.

  : 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() [2/2]

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.

  : 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::~G4SphericalSurface ( )

virtual

Definition at line 183 of file G4SphericalSurface.cc.

{
}

Member Function Documentation

Area()

G4double G4SphericalSurface::Area ( ) const

virtual

Definition at line 831 of file G4SphericalSurface.cc.

{
  // Returns the Area of a G4SphericalSurface
 
  return ( 2.0*( theta_2 - theta_1 )*( phi_2 - phi_1)*radius*radius/pi );
}

CalcBBox()

void G4SphericalSurface::CalcBBox ( )

virtual

Reimplemented from G4Surface.

Definition at line 337 of file G4SphericalSurface.cc.

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

Comp()

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

inline

GetEntityType()

G4String G4SphericalSurface::GetEntityType ( ) const

inlinevirtual

Reimplemented from G4Surface.

GetPhi1()

G4double G4SphericalSurface::GetPhi1 ( ) const

inline

GetPhi2()

G4double G4SphericalSurface::GetPhi2 ( ) const

inline

GetRadius()

G4double G4SphericalSurface::GetRadius ( ) const

inline

Referenced by Intersect().

GetTheta1()

G4double G4SphericalSurface::GetTheta1 ( ) const

inline

GetTheta2()

G4double G4SphericalSurface::GetTheta2 ( ) const

inline

GetXAxis()

G4Vector3D G4SphericalSurface::GetXAxis ( ) const

inline

GetZAxis()

G4Vector3D G4SphericalSurface::GetZAxis ( ) const

inline

HowNear()

G4double G4SphericalSurface::HowNear ( const G4Vector3D &  x ) const

virtual

Reimplemented from G4Surface.

Definition at line 233 of file G4SphericalSurface.cc.

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

Referenced by Inside(), and Intersect().

Inside()

G4int G4SphericalSurface::Inside ( const G4Vector3D &  x ) const

virtual

Definition at line 756 of file G4SphericalSurface.cc.

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

Intersect()

G4int G4SphericalSurface::Intersect ( const G4Ray &  ry )

virtual

Reimplemented from G4Surface.

Definition at line 352 of file G4SphericalSurface.cc.

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

NameOf()

const char * G4SphericalSurface::NameOf ( ) const

virtual

Definition at line 215 of file G4SphericalSurface.cc.

{
  return "G4SphericalSurface";
}

Normal()

G4Vector3D G4SphericalSurface::Normal ( const G4Vector3D &  p ) const

virtual

Reimplemented from G4Surface.

Definition at line 720 of file G4SphericalSurface.cc.

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

Referenced by Intersect().

operator==()

G4int G4SphericalSurface::operator== ( const G4SphericalSurface &  s )

inline

PrintOn()

void G4SphericalSurface::PrintOn ( std::ostream &  os = G4cout ) const

virtual

Definition at line 220 of file G4SphericalSurface.cc.

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

resize()

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

virtual

Definition at line 839 of file G4SphericalSurface.cc.

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

Scale()

G4double G4SphericalSurface::Scale ( ) const

virtual

Definition at line 820 of file G4SphericalSurface.cc.

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

SurfaceNormal()

G4Vector3D G4SphericalSurface::SurfaceNormal ( const G4Point3D &  p ) const

virtual

Implements G4Surface.

Definition at line 738 of file G4SphericalSurface.cc.

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

WithinBoundary()

G4int G4SphericalSurface::WithinBoundary ( const G4Vector3D &  x ) const

virtual

Definition at line 768 of file G4SphericalSurface.cc.

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

Referenced by Intersect().

Member Data Documentation

phi_1

G4double G4SphericalSurface::phi_1

protected

Definition at line 213 of file G4SphericalSurface.hh.

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

phi_2

G4double G4SphericalSurface::phi_2

protected

Definition at line 217 of file G4SphericalSurface.hh.

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

radius

G4double G4SphericalSurface::radius

protected

Definition at line 210 of file G4SphericalSurface.hh.

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

theta_1

G4double G4SphericalSurface::theta_1

protected

Definition at line 221 of file G4SphericalSurface.hh.

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

theta_2

G4double G4SphericalSurface::theta_2

protected

Definition at line 225 of file G4SphericalSurface.hh.

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

x_axis

G4Vector3D G4SphericalSurface::x_axis

protected

Definition at line 202 of file G4SphericalSurface.hh.

Referenced by G4SphericalSurface(), PrintOn(), and WithinBoundary().

z_axis

G4Vector3D G4SphericalSurface::z_axis

protected

Definition at line 206 of file G4SphericalSurface.hh.

Referenced by G4SphericalSurface(), PrintOn(), and WithinBoundary().

---

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

• G4SphericalSurface.hh
• G4SphericalSurface.cc