#include <G4FConicalSurface.hh>

Inheritance diagram for G4FConicalSurface:

Public Member Functions
	G4FConicalSurface ()

virtual	~G4FConicalSurface ()

	G4FConicalSurface (const G4Point3D &o, const G4Vector3D &a, G4double l, G4double sr, G4double lr)

virtual G4Vector3D	SurfaceNormal (const G4Point3D &p) const

G4int	Inside (const G4Vector3D &x) const

G4String	GetEntityType () const

virtual const char *	Name () const

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

G4int	operator== (const G4FConicalSurface &c) const

G4int	Intersect (const G4Ray &ry)

void	CalcBBox ()

virtual G4double	HowNear (const G4Vector3D &x) const

virtual G4int	WithinBoundary (const G4Vector3D &x) const

virtual G4double	Scale () const

virtual G4double	Area () const

virtual void	resize (G4double l, G4double sr, G4double lr)

G4double	GetLength () const

G4double	GetSmallRadius () const

G4double	GetLargeRadius () const

G4double	GetTan_Angle () 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
G4double	length

G4double	small_radius

G4double	large_radius

G4Axis2Placement3D	Position

G4double	tan_angle

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 63 of file G4FConicalSurface.hh.

Constructor & Destructor Documentation

◆ G4FConicalSurface() [1/2]

G4FConicalSurface::G4FConicalSurface ( )

Definition at line 42 of file G4FConicalSurface.cc.

{
  length       = 1.0;
  small_radius = 0.0;
  large_radius = 1.0;
  tan_angle = (large_radius-small_radius)/length;
}

◆ ~G4FConicalSurface()

G4FConicalSurface::~G4FConicalSurface ( )

virtual

Definition at line 50 of file G4FConicalSurface.cc.

51{

52}

◆ G4FConicalSurface() [2/2]

G4FConicalSurface::G4FConicalSurface	(	const G4Point3D &	o,
		const G4Vector3D &	a,
		G4double	l,
		G4double	sr,
		G4double	lr
	)

Definition at line 54 of file G4FConicalSurface.cc.

{
  // Make a G4FConicalSurface with origin o, axis a, length l, small radius 
  // srad, and large radius lr. The angle is calculated below and the SetAngle
  // function of G4ConicalSurface is used to set it properly from the default
  // value used above in the initialization.
 
  // Create the position with origin o, axis a, and a direction
 
  G4Vector3D dir(1,1,1);
  Position.Init(dir, a, o);
  origin = o;
  
  //  Require length to be nonnegative
  if (l >=0)
    length = l;
  else 
  {
    std::ostringstream message;
    message << "Negative length." << G4endl
        << "Default length of 0.0 is used.";    
    G4Exception("G4FConicalSurface::G4FConicalSurface()",
                "GeomSolids1001", JustWarning, message);
 
    length = 0.0;
  }
  
  //  Require small radius to be non-negative (i.e., allow zero)
  if ( srad >= 0.0 )
    small_radius = srad;
  else 
  {
    std::ostringstream message;
    message << "Negative small radius." << G4endl
        << "Default value of 0.0 is used.";    
    G4Exception("G4FConicalSurface::G4FConicalSurface()",
                "GeomSolids1001", JustWarning, message);
   
    small_radius = 0.0;
  }
 
  //  Require large radius to exceed small radius
  if ( lr > small_radius )
    large_radius = lr;
  else 
  {
    std::ostringstream message;
    message << "Large radius must exceed small radius" << G4endl
        << "Default value of small radius +1 is used.";    
    G4Exception("G4FConicalSurface::G4FConicalSurface()",
                "GeomSolids1001", JustWarning, message);
 
    large_radius = small_radius + 1.0;
  }
 
  //  Calculate the angle of the G4ConicalSurface from the length and radii
  tan_angle =  ( large_radius - small_radius ) / length ;
}

Member Function Documentation

◆ Area()

G4double G4FConicalSurface::Area ( ) const

virtual

Definition at line 211 of file G4FConicalSurface.cc.

{ 
 //  Returns the Area of a G4FConicalSurface
  G4double rdif = large_radius - small_radius; 
  
  return ( pi * ( small_radius + large_radius ) * 
       std::sqrt( length * length  +  rdif * rdif ) );
}

◆ CalcBBox()

void G4FConicalSurface::CalcBBox ( )

virtual

Reimplemented from G4Surface.

Definition at line 125 of file G4FConicalSurface.cc.

{
  G4Point3D Max   = G4Point3D(-PINFINITY);
  G4Point3D Min   = G4Point3D( PINFINITY);
  G4Point3D Tmp;
 
  G4Point3D Origin    = Position.GetLocation();
  G4Point3D EndOrigin = G4Point3D( Origin + (length * Position.GetAxis()) );
  
  G4double radius = large_radius;
  G4Point3D Radius(radius, radius, 0);
 
  // Default BBox
  G4Point3D Tolerance(kCarTolerance, kCarTolerance, kCarTolerance);
  G4Point3D BoxMin(Origin-Tolerance);
  G4Point3D BoxMax(Origin+Tolerance);
 
  bbox = new G4BoundingBox3D();
  bbox->Init(BoxMin, BoxMax);
 
  Tmp = (Origin - Radius);
  bbox->Extend(Tmp);
  
  Tmp = Origin + Radius;
  bbox->Extend(Tmp);
 
  Tmp = EndOrigin - Radius;
  bbox->Extend(Tmp);
  
  Tmp = EndOrigin + Radius;
  bbox->Extend(Tmp);
}

◆ GetEntityType()

G4String G4FConicalSurface::GetEntityType ( ) const

inlinevirtual

Reimplemented from G4Surface.

◆ GetLargeRadius()

G4double G4FConicalSurface::GetLargeRadius ( ) const

inline

◆ GetLength()

G4double G4FConicalSurface::GetLength ( ) const

inline

◆ GetSmallRadius()

G4double G4FConicalSurface::GetSmallRadius ( ) const

inline

◆ GetTan_Angle()

G4double G4FConicalSurface::GetTan_Angle ( ) const

inline

◆ HowNear()

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

virtual

Reimplemented from G4Surface.

Definition at line 360 of file G4FConicalSurface.cc.

{ 
//  Shortest distance from the point x to the G4FConicalSurface.
//  The distance will be always positive
//  This function works only with Cone axis equal (0,0,1) or (0,0,-1), it project
//  the surface and the point on the x,z plane and compute the distance in analytical
//  way
  
  G4double   hownear ;
 
  G4Vector3D upcorner = G4Vector3D ( small_radius, 0 , origin.z()+Position.GetAxis().z()*length);
  G4Vector3D downcorner = G4Vector3D ( large_radius, 0 , origin.z());
  G4Vector3D xd;  
  
  xd = G4Vector3D ( std::sqrt ( x.x()*x.x() + x.y()*x.y() ) , 0 , x.z() );
    
  G4double r = (upcorner.z() - downcorner.z()) / (upcorner.x() - downcorner.x());
  G4double q = (downcorner.z()*upcorner.x() - upcorner.z()*downcorner.x()) /
               (upcorner.x() - downcorner.x());
  
  G4double Zinter = (xd.z()*r*r + xd.x()*r +q)/(1+r*r) ;
  
  if ( ((Zinter >= downcorner.z()) && (Zinter <=upcorner.z())) ||
       ((Zinter >= upcorner.z()) && (Zinter <=downcorner.z())) ) {
    hownear = std::fabs(r*xd.x()-xd.z()+q)/std::sqrt(1+r*r);
    return hownear;
  } else {
    hownear = std::min ( (xd-upcorner).mag() , (xd-downcorner).mag() );
    return hownear;
  }
}

Referenced by Inside().

◆ Inside()

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

Definition at line 414 of file G4FConicalSurface.cc.

{ 
  // Return 0 if point x is outside G4ConicalSurface, 1 if Inside.
  if ( HowNear( x ) >= -0.5*kCarTolerance )
    return 1;
  else
    return 0; 
}

Referenced by Intersect().

◆ Intersect()

G4int G4FConicalSurface::Intersect ( const G4Ray & ry )

virtual

Reimplemented from G4Surface.

Definition at line 274 of file G4FConicalSurface.cc.

{ 
  // This function count the number of intersections of a 
  // bounded conical surface by a ray.
  // At first, calculates the intersections with the semi-infinite 
  // conical surfsace. After, count the intersections within the
  // finite conical surface boundaries, and set "distance" to the 
  // closest distance from the start point to the nearest intersection
  // If the point is on the surface it returns or the intersection with
  // the opposite surface or kInfinity
  // If no intersection is founded, set distance = kInfinity and
  // return 0
 
  distance    = kInfinity;
  closest_hit = PINFINITY;
 
  // origin and direction of the ray
  G4Point3D  x    = ry.GetStart();
  G4Vector3D dhat = ry.GetDir();
 
  // cone angle and axis
  G4double   ta   = tan_angle;
  G4Vector3D ahat = Position.GetAxis();
 
  //  array of solutions in distance along the ray
  G4double sol[2];
  sol[0]=-1.0;
  sol[1]=-1.0;
 
  // calculate the two intersections (quadratic equation)   
  G4Vector3D gamma =  G4Vector3D( x - Position.GetLocation() );
  
  G4double t  = 1  +  ta * ta;
  G4double ga = gamma * ahat;
  G4double da = dhat * ahat;
 
  G4double A = t * da * da - dhat * dhat;
  G4double B = 2 * ( -gamma * dhat + t * ga * da - large_radius * ta * da);
  G4double C = ( -gamma * gamma + t * ga * ga 
         - 2 * large_radius * ta * ga
         + large_radius * large_radius );
 
  G4double radical = B * B  -  4.0 * A * C; 
 
  if ( radical < 0.0 ) 
    // no intersection
    return 0;
  else 
  {
    G4double root = std::sqrt( radical );
    sol[0] = ( - B + root ) / ( 2. * A );
    sol[1] = ( - B - root ) / ( 2. * A );
  }
  
  // validity of the solutions
  // the hit point must be into the bounding box of the conical surface
  G4Point3D p0 = G4Point3D( x + sol[0]*dhat );
  G4Point3D p1 = G4Point3D( x + sol[1]*dhat );
  
  if( !GetBBox()->Inside(p0) )
    sol[0] = kInfinity;
 
  if( !GetBBox()->Inside(p1) )
    sol[1] = kInfinity;
 
  // now loop over each positive solution, keeping the first one (smallest
  // distance along the ray) which is within the boundary of the sub-shape
  G4int nbinter = 0;
  distance = kInfinity;
 
  for ( G4int i = 0; i < 2; i++ ) 
  {  
    if(sol[i] < kInfinity) {
      if ( (sol[i] > kCarTolerance*0.5)  ) {
    nbinter++;
    if ( distance > (sol[i]*sol[i]) ) {
      distance = sol[i]*sol[i];
    }
      }
    }
  }
 
  return nbinter;
}

◆ Name()

const char * G4FConicalSurface::Name ( ) const

virtual

Reimplemented from G4Surface.

Definition at line 119 of file G4FConicalSurface.cc.

{
  return "G4FConicalSurface";
}

◆ operator==()

G4int G4FConicalSurface::operator== ( const G4FConicalSurface & c ) const

Definition at line 170 of file G4FConicalSurface.cc.

{
  return ( origin             == c.origin                &&
       Position.GetAxis() == c.Position.GetAxis()    &&
       small_radius       == c.small_radius          && 
       large_radius       == c.large_radius          && 
       length             == c.length                &&
       tan_angle          == c.tan_angle                );
}

◆ PrintOn()

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

virtual

Definition at line 159 of file G4FConicalSurface.cc.

{ 
  //  printing function using C++ std::ostream class
  os << "G4FConicalSurface with origin: " << origin << "\t"
     << "and axis: " << Position.GetAxis() << "\n"
     << "\t small radius: " << small_radius 
     << "\t large radius: " << large_radius
     << "\t and length: " << length << "\n";
}

◆ resize()

void G4FConicalSurface::resize	(	G4double	l,
		G4double	sr,
		G4double	lr
	)

virtual

Definition at line 221 of file G4FConicalSurface.cc.

{
  //  Resize a G4FConicalSurface to a new length l, and new radii srad and lr.
  //  Must Reset angle of the G4ConicalSurface as well based on these new 
  //  values.
  //  Require length to be non-negative
  
  //    if ( l > 0.0 )
  if ( l >= 0.0 )
    length = l;
  else 
  {
    std::ostringstream message;
    message << "Negative length." << G4endl
        << "Original value of " << length << " is retained.";    
    G4Exception("G4FConicalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
 
  //  Require small radius to be non-negative (i.e., allow zero)
  if ( srad >= 0.0 )
    small_radius = srad;
  else 
  {
    std::ostringstream message;
    message << "Negative small radius." << G4endl
        << "Original value of " << small_radius << " is retained.";    
    G4Exception("G4FConicalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
 
  //  Require large radius to exceed small radius
  if ( lr > small_radius )
    large_radius = lr;
  else 
  {
    G4double r = small_radius + 1.0;
    lr = ( large_radius <= small_radius ) ? r : large_radius;
    large_radius = lr;
    
    std::ostringstream message;
    message << "Large radius must exceed small radius." << G4endl
        << "Default value of " << large_radius << " is used.";    
    G4Exception("G4FConicalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
 
  //  Calculate the angle of the G4ConicalSurface from the length and radii
  tan_angle =  ( large_radius - small_radius ) / length ;
 
}

◆ Scale()

G4double G4FConicalSurface::Scale ( ) const

virtual

Definition at line 199 of file G4FConicalSurface.cc.

{  
  //  Returns the small radius of a G4FConicalSurface unless it is zero, in 
  //  which case returns the large radius.
  //  Used for Scale-invariant tests of surface thickness.
  if ( small_radius == 0.0 )
    return large_radius;
  else
    return small_radius;
}

◆ SurfaceNormal()

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

virtual

Implements G4Surface.

Definition at line 393 of file G4FConicalSurface.cc.

{  
  //  return the Normal unit vector to the G4ConicalSurface at a point p 
  //  on (or nearly on) the G4ConicalSurface
  G4Vector3D ss = G4Vector3D( p - origin );
  G4double   da = ss * Position.GetAxis();
  G4double   r  = std::sqrt( ss*ss - da*da);
  G4double   z  = tan_angle * r; 
  
  if (Position.GetAxis().z() < 0)
    z = -z; 
 
  G4Vector3D n(p.x(), p.y(), z);
  n = n.unit();
  
  if( !sameSense )
    n = -n;
 
  return n; 
}

◆ WithinBoundary()

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

virtual

Definition at line 181 of file G4FConicalSurface.cc.

{ 
  //  return 1 if point x is within the boundaries of the G4FConicalSurface
  //  return 0 otherwise (assume it is on the G4ConicalSurface)
  G4Vector3D q = G4Vector3D( x - origin );
  
  G4double qmag = q.mag();
  G4double ss   = std::sin( std::atan2(large_radius-small_radius, length) );
  G4double ls   = small_radius / ss;
  G4double ll   = large_radius / ss;
  
  if ( ( qmag >= ls )  &&  ( qmag <= ll ) )
    return 1;
  else
    return 0;
}

Member Data Documentation

◆ large_radius

G4double G4FConicalSurface::large_radius

protected

Definition at line 149 of file G4FConicalSurface.hh.

Referenced by Area(), CalcBBox(), G4FConicalSurface(), HowNear(), Intersect(), operator==(), PrintOn(), resize(), Scale(), and WithinBoundary().

◆ length

G4double G4FConicalSurface::length

protected

Definition at line 144 of file G4FConicalSurface.hh.

Referenced by Area(), CalcBBox(), G4FConicalSurface(), HowNear(), operator==(), PrintOn(), resize(), and WithinBoundary().

◆ Position

G4Axis2Placement3D G4FConicalSurface::Position

protected

Definition at line 154 of file G4FConicalSurface.hh.

Referenced by CalcBBox(), G4FConicalSurface(), HowNear(), Intersect(), operator==(), PrintOn(), and SurfaceNormal().

◆ small_radius

G4double G4FConicalSurface::small_radius

protected

Definition at line 147 of file G4FConicalSurface.hh.

Referenced by Area(), G4FConicalSurface(), HowNear(), operator==(), PrintOn(), resize(), Scale(), and WithinBoundary().

◆ tan_angle

G4double G4FConicalSurface::tan_angle

protected

Definition at line 155 of file G4FConicalSurface.hh.

Referenced by G4FConicalSurface(), Intersect(), operator==(), resize(), and SurfaceNormal().

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4FConicalSurface() [1/2]

◆ ~G4FConicalSurface()

◆ G4FConicalSurface() [2/2]

Member Function Documentation

◆ Area()

◆ CalcBBox()

◆ GetEntityType()

◆ GetLargeRadius()

◆ GetLength()

◆ GetSmallRadius()

◆ GetTan_Angle()

◆ HowNear()

◆ Inside()

◆ Intersect()

◆ Name()

◆ operator==()

◆ PrintOn()

◆ resize()

◆ Scale()

◆ SurfaceNormal()

◆ WithinBoundary()

Member Data Documentation

◆ large_radius

◆ length

◆ Position

◆ small_radius

◆ tan_angle