#include <G4CylindricalSurface.hh>

Inheritance diagram for G4CylindricalSurface:

Public Member Functions
	G4CylindricalSurface ()

	G4CylindricalSurface (const G4Vector3D &o, const G4Vector3D &a, G4double r)

virtual	~G4CylindricalSurface ()

G4int	operator== (const G4CylindricalSurface &c) const

G4String	GetEntityType () const

virtual const char *	NameOf () const

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

virtual G4double	HowNear (const G4Vector3D &x) const

virtual G4Vector3D	Normal (const G4Vector3D &p) 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

G4int	Intersect (const G4Ray &ry)

G4Vector3D	GetAxis () const

G4double	GetRadius () const

void	SetRadius (G4double r)

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	axis

G4double	radius

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 48 of file G4CylindricalSurface.hh.

Constructor & Destructor Documentation

◆ G4CylindricalSurface() [1/2]

G4CylindricalSurface::G4CylindricalSurface ( )

Definition at line 40 of file G4CylindricalSurface.cc.

                                           : G4Surface()
{  
  // default constructor
  // default axis is ( 1.0, 0.0, 0.0 ), default radius is 1.0
 
  axis = G4Vector3D( 1.0, 0.0, 0.0 );
  radius = 1.0;
}

◆ G4CylindricalSurface() [2/2]

G4CylindricalSurface::G4CylindricalSurface	(	const G4Vector3D &	o,
		const G4Vector3D &	a,
		G4double	r
	)

Definition at line 50 of file G4CylindricalSurface.cc.

  : G4Surface()
{ 
  // Normal constructor
  // require axis to be a unit vector
 
  G4double amag = a.mag();
  if ( amag != 0.0 )
  {
    axis = a * (1/ amag);  // this makes the axis a unit vector
  }
  else 
  {
    std::ostringstream message;
    message << "Axis has zero length." << G4endl
        << "Default axis ( 1.0, 0.0, 0.0 ) is used.";    
    G4Exception("G4CylindricalSurface::G4CylindricalSurface()",
                "GeomSolids1001", JustWarning, message);
    
    axis = G4Vector3D( 1.0, 0.0, 0.0 );
  }
 
  //  Require radius to be non-negative
  //
  if ( r >= 0.0 )
  {
    radius = r;
  }
  else 
  {
    std::ostringstream message;
    message << "Negative radius." << G4endl
        << "Default radius of 1.0 is used.";    
    G4Exception("G4CylindricalSurface::G4CylindricalSurface()",
                "GeomSolids1001", JustWarning, message);
 
    radius = 1.0;
  }
 
  origin =o;
}

◆ ~G4CylindricalSurface()

G4CylindricalSurface::~G4CylindricalSurface ( )

virtual

Definition at line 95 of file G4CylindricalSurface.cc.

96{

97}

Member Function Documentation

◆ GetAxis()

G4Vector3D G4CylindricalSurface::GetAxis ( ) const

inline

Referenced by Intersect().

◆ GetEntityType()

G4String G4CylindricalSurface::GetEntityType ( ) const

inlinevirtual

Reimplemented from G4Surface.

◆ GetRadius()

G4double G4CylindricalSurface::GetRadius ( ) const

inline

Referenced by Intersect().

◆ HowNear()

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

virtual

Reimplemented from G4Surface.

Definition at line 241 of file G4CylindricalSurface.cc.

{
  //  Distance from the point x to the infinite G4CylindricalSurface.
  //  The distance will be positive if the point is Inside the 
  //  G4CylindricalSurface, negative if the point is outside.
  //  Note that this may not be correct for a bounded cylindrical object
  //  subclassed to G4CylindricalSurface.
 
  G4Vector3D d = x - origin;
  G4double dA = d * axis;
  G4double rds = std::sqrt( d.mag2() - dA*dA );
  G4double hownear = std::fabs( radius - rds );
 
  return hownear;
}

Referenced by Inside(), and WithinBoundary().

◆ Inside()

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

virtual

Definition at line 868 of file G4CylindricalSurface.cc.

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

Referenced by Intersect().

◆ Intersect()

G4int G4CylindricalSurface::Intersect ( const G4Ray & ry )

virtual

Reimplemented from G4Surface.

Definition at line 128 of file G4CylindricalSurface.cc.

{
  //  Distance along a Ray (straight line with G4ThreeVec) to leave or enter
  //  a G4CylindricalSurface.  The input variable which_way should be set 
  //  to +1 to indicate leaving a G4CylindricalSurface, -1 to indicate 
  //  entering a G4CylindricalSurface.
  //  p is the point of intersection of the Ray with the G4CylindricalSurface.
  //  If the G4Vector3D of the Ray is opposite to that of the Normal to
  //  the G4CylindricalSurface at the intersection point, it will not leave 
  //  the G4CylindricalSurface.
  //  Similarly, if the G4Vector3D of the Ray is along that of the Normal 
  //  to the G4CylindricalSurface at the intersection point, it will not enter
  //  the G4CylindricalSurface.
  //  This method is called by all finite shapes sub-classed to 
  //  G4CylindricalSurface.
  //  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;
  
  if(!Inside(ry.GetStart()))  { which_way = -1; }
  
  distance = kInfinity;
  G4Vector3D lv ( kInfinity, kInfinity, kInfinity );
  
  closest_hit = lv;
 
  //  Origin and G4Vector3D unit vector of Ray.
  //
  G4Vector3D x    = ry.GetStart();
  G4Vector3D dhat = ry.GetDir();
 
  //  Axis unit vector of the G4CylindricalSurface.
  //
  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 d    = x - GetOrigin();
  G4double   radiu = GetRadius();
 
  G4double dsq  = d * d;
  G4double da   = d * ahat;
  G4double dasq = da * da;
  G4double rsq  = radiu * radiu;
  G4double qsq  = dsq - dasq;
  G4double dira = dhat * ahat;
  G4double a    = 1.0 - dira * dira;
  
  if ( a <= 0.0 )  { return 0; }
 
  G4double b       = 2. * ( d * dhat - da * dira );
  G4double c       = rsq - qsq;
  G4double radical = b * b + 4. * a * c; 
        
  if ( radical < 0.0 )  { return 0; }
 
  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 G4CylindricalSurface at the intersection point
  //
  for ( isoln = 0; isoln < maxsoln; isoln++ ) 
  {
    if ( sol[isoln] >= kCarTolerance*0.5 ) 
    {
      if ( sol[isoln] >= kInfinity )  // quit if too large
        { return 0; }
 
      distance = sol[isoln];
      closest_hit = ry.GetPoint( distance );
      G4double  tmp =  dhat * (Normal( closest_hit ));
      
      if ((tmp * which_way) >= 0.0 )
      {
        if ( 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 * G4CylindricalSurface::NameOf ( ) const

virtual

Definition at line 117 of file G4CylindricalSurface.cc.

{
  return "G4CylindricalSurface";
}

◆ Normal()

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

virtual

Reimplemented from G4Surface.

Definition at line 840 of file G4CylindricalSurface.cc.

{ 
  //  return the Normal unit vector to the G4CylindricalSurface 
  //  at a point p on (or nearly on) the G4CylindricalSurface
 
  G4Vector3D n = ( p - origin ) - ( ( p - origin ) * axis ) * axis;
  G4double nmag = n.mag();
 
  if ( nmag != 0.0 )  { n = n * (1/nmag); }
  
  return n;
}

Referenced by Intersect().

◆ operator==()

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

inline

◆ PrintOn()

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

virtual

Definition at line 122 of file G4CylindricalSurface.cc.

{
  os << "G4CylindricalSurface surface with origin: " << origin << "\t"
     << "radius: " << radius << "\tand axis " << axis << "\n";
}

◆ Scale()

G4double G4CylindricalSurface::Scale ( ) const

virtual

Definition at line 893 of file G4CylindricalSurface.cc.

{
  //  Returns the radius of a G4CylindricalSurface unless it is zero, in which
  //  case returns the arbitrary number 1.0.
  //  This is ok since derived finite-sized classes will overwrite this.
  //  Used for Scale-invariant tests of surface thickness.
 
  if ( radius == 0.0 )
    { return 1.0; }
  else
    { return radius; }
}

Referenced by WithinBoundary().

◆ SetRadius()

void G4CylindricalSurface::SetRadius ( G4double r )

Definition at line 942 of file G4CylindricalSurface.cc.

{ 
  //  Reset the radius of the G4CylindricalSurface
  //  Require radius to be non-negative
 
  if ( r >= 0.0 )  { radius = r; }
  else   // Use old value (do not change radius) if out of the range, 
  {      // but print warning message
    std::ostringstream message;
    message << "Negative radius." << G4endl
        << "Default radius of " << radius << " is used.";    
    G4Exception("G4CylindricalSurface::SetRadius()",
                "GeomSolids1001", JustWarning, message);
  }
}

◆ SurfaceNormal()

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

virtual

Implements G4Surface.

Definition at line 854 of file G4CylindricalSurface.cc.

{
  //  return the Normal unit vector to the G4CylindricalSurface at a point 
  //  p on (or nearly on) the G4CylindricalSurface
  
  G4Vector3D n = ( p - origin ) - ( ( p - origin ) * axis ) * axis;
  G4double nmag = n.mag();
  
  if ( nmag != 0.0 )  { n = n * (1/nmag); }
  
  return n;
}

◆ WithinBoundary()

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

virtual

Definition at line 881 of file G4CylindricalSurface.cc.

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

Referenced by Intersect().

Member Data Documentation

◆ axis

G4Vector3D G4CylindricalSurface::axis

protected

Definition at line 177 of file G4CylindricalSurface.hh.

Referenced by G4CylindricalSurface(), HowNear(), Normal(), PrintOn(), and SurfaceNormal().

◆ radius

G4double G4CylindricalSurface::radius

protected

Definition at line 180 of file G4CylindricalSurface.hh.

Referenced by G4CylindricalSurface(), HowNear(), PrintOn(), Scale(), and SetRadius().

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4CylindricalSurface() [1/2]

◆ G4CylindricalSurface() [2/2]

◆ ~G4CylindricalSurface()

Member Function Documentation

◆ GetAxis()

◆ GetEntityType()

◆ GetRadius()

◆ HowNear()

◆ Inside()

◆ Intersect()

◆ NameOf()

◆ Normal()

◆ operator==()

◆ PrintOn()

◆ Scale()

◆ SetRadius()

◆ SurfaceNormal()

◆ WithinBoundary()

Member Data Documentation

◆ axis

◆ radius