#include <G4ConicalSurface.hh>

Inheritance diagram for G4ConicalSurface:

Public Member Functions
	G4ConicalSurface ()

	G4ConicalSurface (const G4Point3D &o, const G4Vector3D &a, G4double e)

virtual	~G4ConicalSurface ()

G4int	operator== (const G4ConicalSurface &c)

G4String	GetEntityType () const

virtual const char *	NameOf () const

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

virtual G4double	HowNear (const G4Vector3D &x) const

void	CalcBBox ()

G4int	Intersect (const G4Ray &ry)

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

G4Vector3D	GetAxis () const

G4double	GetAngle () const

void	SetAngle (G4double e)

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

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 ()

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

Detailed Description

Definition at line 51 of file G4ConicalSurface.hh.

Constructor & Destructor Documentation

◆ G4ConicalSurface() [1/2]

G4ConicalSurface::G4ConicalSurface ( )

Definition at line 42 of file G4ConicalSurface.cc.

  : G4Surface(), axis(G4Vector3D(1.,0.,0.)), angle(1.)
{  
}

◆ G4ConicalSurface() [2/2]

G4ConicalSurface::G4ConicalSurface	(	const G4Point3D &	o,
		const G4Vector3D &	a,
		G4double	e
	)

Definition at line 47 of file G4ConicalSurface.cc.

  : G4Surface()
{  
  // Normal constructor
  // require axis to be a unit vector
 
  G4double amag = a.mag2();
 
  if ( amag != 0.0 )
  {
    axis = a*(1/amag);
  }
  else
  {
    std::ostringstream message;
    message << "Axis has zero length." << G4endl
        << "Default axis ( 1.0, 0.0, 0.0 ) is used.";
    G4Exception("G4ConicalSurface::G4ConicalSurface()", "GeomSolids1001",
                JustWarning, message);
 
    axis = G4Vector3D( 1.0, 0.0, 0.0 );
  }
 
  //  Require angle to range from 0 to PI/2
  //
  if ( ( e > 0.0 ) && ( e < ( 0.5 * pi ) ) )
  {
    angle = e;
  }
  else
  {
    std::ostringstream message;
    message << "Angle out of range." << G4endl
            << "Asked for angle out of allowed range of 0 to "
        << 0.5*pi << " (PI/2): " << e << G4endl
        << "Default angle of 1.0 is used.";    
    G4Exception("G4ConicalSurface::G4ConicalSurface()", "GeomSolids1001",
                JustWarning, message);
    angle = 1.0;
  }
}

◆ ~G4ConicalSurface()

G4ConicalSurface::~G4ConicalSurface ( )

virtual

Definition at line 92 of file G4ConicalSurface.cc.

93{

94}

Member Function Documentation

◆ CalcBBox()

void G4ConicalSurface::CalcBBox ( )

virtual

Reimplemented from G4Surface.

Definition at line 119 of file G4ConicalSurface.cc.

{
  bbox= new G4BoundingBox3D(surfaceBoundary.BBox().GetBoxMin(), 
                            surfaceBoundary.BBox().GetBoxMax());
}

◆ GetAngle()

G4double G4ConicalSurface::GetAngle ( ) const

inline

Referenced by Intersect().

◆ GetAxis()

G4Vector3D G4ConicalSurface::GetAxis ( ) const

inline

Referenced by Intersect().

◆ GetEntityType()

G4String G4ConicalSurface::GetEntityType ( ) const

inlinevirtual

Reimplemented from G4Surface.

◆ HowNear()

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

virtual

Reimplemented from G4Surface.

Definition at line 134 of file G4ConicalSurface.cc.

{ 
  // Distance from the point x to the semi-infinite G4ConicalSurface.
  // The distance will be positive if the point is Inside the G4ConicalSurface,
  // negative if the point is outside.
  // Note that this may not be correct for a bounded conical object
  // subclassed to G4ConicalSurface.
 
  G4Vector3D d    = G4Vector3D( x - origin );
  G4double   l    = d * axis;
  G4Vector3D q    = G4Vector3D( origin  +  l * axis );
  G4Vector3D v    = G4Vector3D( x - q );
 
  G4double   Dist = ( l*std::tan(angle) - v.mag2() ) * std::cos(angle);
 
  return Dist;
}

Referenced by Inside(), Intersect(), and WithinBoundary().

◆ Inside()

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

virtual

Definition at line 538 of file G4ConicalSurface.cc.

{ 
  // Return 0 if point x is outside G4ConicalSurface, 1 if Inside.
  // Outside means that the distance to the G4ConicalSurface would be negative.
  // Use the HowNear function to calculate this distance.
 
  if ( HowNear( x ) >= -0.5*kCarTolerance )
    { return 1; }
  else
    { return 0; }
}

◆ Intersect()

G4int G4ConicalSurface::Intersect ( const G4Ray & ry )

virtual

Reimplemented from G4Surface.

Definition at line 153 of file G4ConicalSurface.cc.

{
  //  Distance along a Ray (straight line with G4Vector3D) to leave or enter
  //  a G4ConicalSurface.  The input variable which_way should be set to +1 to
  //  indicate leaving a G4ConicalSurface, -1 to indicate entering a 
  //  G4ConicalSurface.
  //  p is the point of intersection of the Ray with the G4ConicalSurface.
  //  If the G4Vector3D of the Ray is opposite to that of the Normal to
  //  the G4ConicalSurface at the intersection point, it will not leave the 
  //  G4ConicalSurface.
  //  Similarly, if the G4Vector3D of the Ray is along that of the Normal 
  //  to the G4ConicalSurface at the intersection point, it will not enter the
  //  G4ConicalSurface.
  //  This method is called by all finite shapes sub-classed to 
  //  G4ConicalSurface.
  //  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 = -1; // Originally a parameter.Read explanation above. 
 
  distance = kInfinity;
 
  G4Vector3D lv ( kInfinity, kInfinity, kInfinity );
  closest_hit = lv;
 
  //  Origin and G4Vector3D unit vector of Ray.
  //
  G4Vector3D x = G4Vector3D( ry.GetStart() );
  G4Vector3D dhat = ry.GetDir();
  
  
  //  Cone angle and axis unit vector.
  //
  G4double   ta      = std::tan( GetAngle() );
  G4Vector3D ahat    = GetAxis();
  G4int      isoln   = 0, 
             maxsoln = 2;
 
  //  array of solutions in distance along the Ray
  //
  G4double sol[2];
  sol[0] = -1.0; 
  sol[1] = -1.0 ;
 
  //  calculate the two solutions (quadratic equation)
  //
  G4Vector3D gamma = G4Vector3D( x - GetOrigin() );
  G4double   T  = 1.0  +  ta * ta;
  G4double   ga = gamma * ahat;
  G4double   da = dhat * ahat;
  G4double   A  = 1.0 - T * da * da;
  G4double   B  = 2.0 * ( gamma * dhat - T * ga * da );
  G4double   C  = gamma * gamma - T * ga * ga;
 
  //  if quadratic term vanishes, just do the simple solution
  //
  if ( std::fabs( A ) < kCarTolerance ) 
  {
    if ( B == 0.0 )
      { return 1; }
    else
      { sol[0] = -C / B; }
  }
 
  //  Normal quadratic case, no intersection if radical is less than zero
  //
  else 
  {
    G4double radical = B * B  -  4.0 * A * C; 
    if ( radical < 0.0 ) 
    {
      return 1;
    }
    else 
    {
      G4double root = std::sqrt( radical );
      sol[0] = ( - B + root ) / ( 2. * A );
      sol[1] = ( - B - root ) / ( 2. * A );
    }
  }
 
  //  order the possible solutions by increasing distance along the Ray
  //
  sort_double( sol, isoln, maxsoln-1 );
 
  //  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 G4ConicalSurface at the intersection point
  //
  for ( isoln = 0; isoln < maxsoln; isoln++ ) 
  {
    if ( sol[isoln] >= 0.0 ) 
    {
      if ( sol[isoln] >= kInfinity )  // quit if too large
      {
        return 1;
      }
      
      distance = sol[isoln];
      closest_hit = ry.GetPoint( distance );
 
      //  Following line necessary to select non-reflective solutions.
      //
      if (( ahat * ( closest_hit - GetOrigin() ) > 0.0 ) && 
      ((( dhat * SurfaceNormal( closest_hit ) * which_way )) >= 0.0 ) && 
      ( std::fabs(HowNear( closest_hit )) < 0.1)                               )
      {
        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 * G4ConicalSurface::NameOf ( ) const

virtual

Definition at line 114 of file G4ConicalSurface.cc.

{
   return "G4ConicalSurface";
}

◆ operator==()

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

inline

◆ PrintOn()

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

virtual

Definition at line 125 of file G4ConicalSurface.cc.

{ 
  // printing function using C++ std::ostream class
 
  os << "G4ConicalSurface surface with origin: " << origin << "\t"
     << "angle: " << angle << " radians \tand axis " << axis << "\n";
}

◆ Scale()

G4double G4ConicalSurface::Scale ( ) const

virtual

Definition at line 562 of file G4ConicalSurface.cc.

{
  return 1.0;
}

Referenced by WithinBoundary().

◆ SetAngle()

void G4ConicalSurface::SetAngle ( G4double e )

Definition at line 567 of file G4ConicalSurface.cc.

{
  //  Reset the angle of the G4ConicalSurface
  //  Require angle to range from 0 to PI/2
 
  if ( (e > 0.0) && (e <= ( 0.5 * pi )) )
  {
    angle = e;
  }
  else   // use old value (do not change angle) if out of the range, 
  {      // but print warning message
    std::ostringstream message;
    message << "Angle out of range." << G4endl
            << "Asked for angle out of allowed range of 0 to "
        << 0.5*pi << " (PI/2): " << e << G4endl
        << "Default angle of " << angle << " is used.";    
    G4Exception("G4ConicalSurface::SetAngle()", "GeomSolids1001",
                JustWarning, message);
  }
}

◆ SurfaceNormal()

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

virtual

Implements G4Surface.

Definition at line 497 of file G4ConicalSurface.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   smag = ss.mag2();
  
  //  if the point happens to be at the origin, calculate a unit vector Normal
  //  to the axis, with zero z component
  //
  if ( smag == 0.0 )
  {
    G4double ax = axis.x();
    G4double ay = axis.y();
    G4double ap = std::sqrt( ax * ax  +  ay * ay );
 
    if ( ap == 0.0 )
      { return G4Vector3D( 1.0, 0.0, 0.0 ); }
    else
      { return G4Vector3D( ay / ap, -ax / ap, 0.0 ); }
  }
  else  // otherwise do the calculation of the Normal to the conical surface
  {
    G4double l = ss * axis;
    ss = ss*(1/smag);
    G4Vector3D q    = G4Vector3D( origin  +  l * axis );
    G4Vector3D v    = G4Vector3D( p - q );
    G4double   sl   = v.mag2() * std::sin( angle );
    G4Vector3D n    = G4Vector3D( v - sl * ss );
    G4double   nmag = n.mag2(); 
 
    if ( nmag != 0.0 )
    {
      n=n*(1/nmag);
    }
    return n;
  }
}

Referenced by Intersect().

◆ WithinBoundary()

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

virtual

Definition at line 551 of file G4ConicalSurface.cc.

{  
  //  return 1 if point x is on the G4ConicalSurface, otherwise return zero
  //  base this on the surface precision factor
 
  if ( std::fabs( HowNear( x ) / Scale() ) <= SURFACE_PRECISION )
    { return 1; }
  else
    { return 0; }
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4ConicalSurface() [1/2]

◆ G4ConicalSurface() [2/2]

◆ ~G4ConicalSurface()

Member Function Documentation

◆ CalcBBox()

◆ GetAngle()

◆ GetAxis()

◆ GetEntityType()

◆ HowNear()

◆ Inside()

◆ Intersect()

◆ NameOf()

◆ operator==()

◆ PrintOn()

◆ Scale()

◆ SetAngle()

◆ SurfaceNormal()

◆ WithinBoundary()