G4FConicalSurface Class Reference

#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
Protected Attributes
G4double	length
G4double	small_radius
G4double	large_radius
G4Axis2Placement3D	Position
G4double	tan_angle

---

Detailed Description

Definition at line 63 of file G4FConicalSurface.hh.

---

Constructor & Destructor Documentation

G4FConicalSurface::G4FConicalSurface

(

)

Definition at line 42 of file G4FConicalSurface.cc.

References large_radius, length, small_radius, and tan_angle.

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

G4FConicalSurface::~G4FConicalSurface

(

)

[virtual]

Definition at line 50 of file G4FConicalSurface.cc.

{
}

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

Definition at line 54 of file G4FConicalSurface.cc.

References G4endl, G4Exception(), G4Axis2Placement3D::Init(), JustWarning, large_radius, length, G4Surface::origin, Position, small_radius, and tan_angle.

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

G4double G4FConicalSurface::Area

(

)

const [virtual]

Definition at line 211 of file G4FConicalSurface.cc.

References large_radius, length, G4INCL::Math::pi, and small_radius.

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

void G4FConicalSurface::CalcBBox

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 125 of file G4FConicalSurface.cc.

References G4Surface::bbox, G4BoundingBox3D::Extend(), G4Axis2Placement3D::GetAxis(), G4Axis2Placement3D::GetLocation(), G4BoundingBox3D::Init(), G4Surface::kCarTolerance, large_radius, length, PINFINITY(), and Position.

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

G4String G4FConicalSurface::GetEntityType

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 38 of file G4FConicalSurface.icc.

{
  return G4String("FConical_Surface");
}

G4double G4FConicalSurface::GetLargeRadius

(

)

const [inline]

Definition at line 56 of file G4FConicalSurface.icc.

References large_radius.

{
  return large_radius;
}

G4double G4FConicalSurface::GetLength

(

)

const [inline]

Definition at line 44 of file G4FConicalSurface.icc.

References length.

{
  return length;
}

G4double G4FConicalSurface::GetSmallRadius

(

)

const [inline]

Definition at line 50 of file G4FConicalSurface.icc.

References small_radius.

{
  return small_radius;
}

G4double G4FConicalSurface::GetTan_Angle

(

)

const [inline]

Definition at line 62 of file G4FConicalSurface.icc.

References tan_angle.

{
  return tan_angle;
}

G4double G4FConicalSurface::HowNear

(

const G4Vector3D &

x

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 360 of file G4FConicalSurface.cc.

References G4Axis2Placement3D::GetAxis(), large_radius, length, G4Surface::origin, Position, and small_radius.

Referenced by Inside().

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

G4int G4FConicalSurface::Inside

(

const G4Vector3D &

x

)

const

Definition at line 414 of file G4FConicalSurface.cc.

References HowNear(), and G4Surface::kCarTolerance.

Referenced by Intersect().

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

G4int G4FConicalSurface::Intersect

(

const G4Ray &

ry

)

[virtual]

Reimplemented from G4Surface.

Definition at line 274 of file G4FConicalSurface.cc.

References G4Surface::closest_hit, G4Surface::distance, G4Axis2Placement3D::GetAxis(), G4Surface::GetBBox(), G4Ray::GetDir(), G4Axis2Placement3D::GetLocation(), G4Ray::GetStart(), Inside(), G4Surface::kCarTolerance, large_radius, PINFINITY(), Position, and tan_angle.

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

const char * G4FConicalSurface::Name

(

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 119 of file G4FConicalSurface.cc.

{
  return "G4FConicalSurface";
}

G4int G4FConicalSurface::operator==

(

const G4FConicalSurface &

c

)

const

Definition at line 170 of file G4FConicalSurface.cc.

References G4Axis2Placement3D::GetAxis(), large_radius, length, G4Surface::origin, Position, small_radius, and tan_angle.

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

void G4FConicalSurface::PrintOn

(

std::ostream &

os = G4cout

)

const [virtual]

Definition at line 159 of file G4FConicalSurface.cc.

References G4Axis2Placement3D::GetAxis(), large_radius, length, G4Surface::origin, Position, and small_radius.

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

void G4FConicalSurface::resize	(	G4double	l,
		G4double	sr,
		G4double	lr
	)			[virtual]

Definition at line 221 of file G4FConicalSurface.cc.

References G4endl, G4Exception(), JustWarning, large_radius, length, small_radius, and tan_angle.

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

G4double G4FConicalSurface::Scale

(

)

const [virtual]

Definition at line 199 of file G4FConicalSurface.cc.

References large_radius, and small_radius.

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

G4Vector3D G4FConicalSurface::SurfaceNormal

(

const G4Point3D &

p

)

const [virtual]

Implements G4Surface.

Definition at line 393 of file G4FConicalSurface.cc.

References G4Axis2Placement3D::GetAxis(), CLHEP::detail::n, G4Surface::origin, Position, G4Surface::sameSense, and tan_angle.

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

G4int G4FConicalSurface::WithinBoundary

(

const G4Vector3D &

x

)

const [virtual]

Definition at line 181 of file G4FConicalSurface.cc.

References large_radius, length, G4Surface::origin, and small_radius.

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

---

Field Documentation

G4double G4FConicalSurface::large_radius [protected]

Definition at line 149 of file G4FConicalSurface.hh.

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

G4double G4FConicalSurface::length [protected]

Definition at line 144 of file G4FConicalSurface.hh.

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

G4Axis2Placement3D G4FConicalSurface::Position [protected]

Definition at line 154 of file G4FConicalSurface.hh.

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

G4double G4FConicalSurface::small_radius [protected]

Definition at line 147 of file G4FConicalSurface.hh.

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

G4double G4FConicalSurface::tan_angle [protected]

Definition at line 155 of file G4FConicalSurface.hh.

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

---

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

• G4FConicalSurface.hh
• G4FConicalSurface.icc
• G4FConicalSurface.cc

---