G4FCylindricalSurface Class Reference

#include <G4FCylindricalSurface.hh>

Inheritance diagram for G4FCylindricalSurface:

Public Member Functions
	G4FCylindricalSurface ()
	G4FCylindricalSurface (const G4Point3D &o, const G4Vector3D &a, G4double r, G4double l)
virtual	~G4FCylindricalSurface ()
G4int	operator== (const G4FCylindricalSurface &c) const
virtual G4Vector3D	SurfaceNormal (const G4Point3D &p) const
virtual G4int	Inside (const G4Vector3D &x) const
G4String	GetEntityType () const
G4int	Intersect (const G4Ray &)
virtual G4double	HowNear (const G4Vector3D &x) const
void	CalcBBox ()
virtual const char *	NameOf () const
virtual void	PrintOn (std::ostream &os=G4cout) const
virtual G4int	WithinBoundary (const G4Vector3D &x) const
virtual G4double	Scale () const
virtual G4double	Area () const
virtual void	resize (G4double r, G4double l)
G4double	GetLength () const
G4Vector3D	GetAxis () const
G4double	GetRadius () const
void	SetRadius (G4double r)
void	InitValues ()
Protected Attributes
G4Axis2Placement3D	Position
G4double	radius
G4double	length

---

Detailed Description

Definition at line 64 of file G4FCylindricalSurface.hh.

---

Constructor & Destructor Documentation

G4FCylindricalSurface::G4FCylindricalSurface

(

)

Definition at line 41 of file G4FCylindricalSurface.cc.

  : radius(0.), length(1.)
{
}

G4FCylindricalSurface::G4FCylindricalSurface	(	const G4Point3D &	o,
		const G4Vector3D &	a,
		G4double	r,
		G4double	l
	)

Definition at line 52 of file G4FCylindricalSurface.cc.

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

{ 
  //  make a G4FCylindricalSurface with origin o, axis a, 
  //  radius r, and length l
  G4Vector3D dir(1,1,1);
  Position.Init(dir, a, o);

  origin = o;
  radius = r;
  
  //  Require length to be positive or zero
  if ( l >= 0.0 )
    length = l;
  else 
  {
    std::ostringstream message;
    message << "Negative length." << G4endl
            << "Default length of 0.0 is used.";    
    G4Exception("G4FCylindricalSurface::G4FCylindricalSurface()",
                "GeomSolids1001", JustWarning, message);

    length = 0.0;
  }

  //  Require radius to be non-negative (i.e., allow zero)
  if ( r >= 0.0 )
    radius = r;
  else 
  {
    std::ostringstream message;
    message << "Negative radius." << G4endl
            << "Default value of 0.0 is used.";    
    G4Exception("G4FCylindricalSurface::G4FCylindricalSurface()",
                "GeomSolids1001", JustWarning, message);

    radius = 0.0;
  }
}

G4FCylindricalSurface::~G4FCylindricalSurface

(

)

[virtual]

Definition at line 47 of file G4FCylindricalSurface.cc.

{
}

---

Member Function Documentation

G4double G4FCylindricalSurface::Area

(

)

const [virtual]

Definition at line 111 of file G4FCylindricalSurface.cc.

References length, G4INCL::Math::pi, and radius.

{
  return ( 2.0 * pi * radius * length );
}

void G4FCylindricalSurface::CalcBBox

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 119 of file G4FCylindricalSurface.cc.

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

{
  // Finds the bounds of the surface iow
  // calculates the bounds for a bounding box
  // to the surface. The bounding box is used
  // for a preliminary check of intersection.
  G4Point3D Max = G4Point3D(-PINFINITY);
  G4Point3D Min = G4Point3D( PINFINITY);

  G4Point3D Tmp; 
  G4Point3D Origin    = Position.GetLocation();
  G4Point3D EndOrigin = G4Point3D( Origin + (length*Position.GetAxis()) );
  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);
}

G4Vector3D G4FCylindricalSurface::GetAxis

(

)

const [inline]

Definition at line 59 of file G4FCylindricalSurface.icc.

References G4Axis2Placement3D::GetAxis(), and Position.

{
  return Position.GetAxis();
}

G4String G4FCylindricalSurface::GetEntityType

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 47 of file G4FCylindricalSurface.icc.

{
  return G4String("Cylindrical_Surface");
}

G4double G4FCylindricalSurface::GetLength

(

)

const [inline]

Definition at line 53 of file G4FCylindricalSurface.icc.

References length.

{ 
  return length; 
}

G4double G4FCylindricalSurface::GetRadius

(

)

const [inline]

Definition at line 65 of file G4FCylindricalSurface.icc.

References radius.

{
  return radius;
}

G4double G4FCylindricalSurface::HowNear

(

const G4Vector3D &

x

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 241 of file G4FCylindricalSurface.cc.

References length, G4Surface::origin, and radius.

Referenced by Inside().

{
  // Shortest distance from the point x to the G4FCylindricalSurface.
  // The distance will be always positive 

  G4double   hownear;

  G4Vector3D upcorner = G4Vector3D ( radius, 0 , origin.z()+length);
  G4Vector3D downcorner = G4Vector3D ( radius, 0 , origin.z());
  G4Vector3D xd;  
  
  xd = G4Vector3D ( std::sqrt ( x.x()*x.x() + x.y()*x.y() ) , 0 , x.z() );
    
  
  G4double Zinter = (xd.z()) ;
  
  if ( ((Zinter >= downcorner.z()) && (Zinter <=upcorner.z())) ) {
    hownear = std::fabs( radius - xd.x() );
  } else {
    hownear = std::min ( (xd-upcorner).mag() , (xd-downcorner).mag() );
  }

  return hownear;
}

void G4FCylindricalSurface::InitValues

(

)

G4int G4FCylindricalSurface::Inside

(

const G4Vector3D &

x

)

const [virtual]

Definition at line 309 of file G4FCylindricalSurface.cc.

References HowNear(), and G4Surface::kCarTolerance.

Referenced by Intersect().

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

G4int G4FCylindricalSurface::Intersect

(

const G4Ray &

)

[virtual]

Reimplemented from G4Surface.

Definition at line 156 of file G4FCylindricalSurface.cc.

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

{
  // This function count the number of intersections of a 
  // bounded cylindrical surface by a ray.
  // At first, calculates the intersections with the infinite 
  // cylindrical surfsace. After, count the intersections within the
  // finite cylindrical 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();

  // cylinder axis 
  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 ga = gamma * ahat;
  G4double da = dhat * ahat;

  G4double A = da * da - dhat * dhat;
  G4double B = 2 * ( -gamma * dhat + ga * da );
  G4double C =  -gamma * gamma + ga * ga  + radius * 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 cylindrical 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 ++;
        // real intersection
        // set the distance if it is the smallest
        if( distance > sol[i]*sol[i]) {
          distance = sol[i]*sol[i];
        }
      }
    }    
  }

  return nbinter;
}

const char * G4FCylindricalSurface::NameOf

(

)

const [virtual]

Definition at line 96 of file G4FCylindricalSurface.cc.

{
  return "G4FCylindricalSurface"; 
}

G4int G4FCylindricalSurface::operator==

(

const G4FCylindricalSurface &

c

)

const [inline]

Definition at line 38 of file G4FCylindricalSurface.icc.

References length, G4Surface::origin, Position, and radius.

{
  return ( origin == c.origin && 
           Position == c.Position   && 
           radius == c.radius && 
           length == c.length    );
}

void G4FCylindricalSurface::PrintOn

(

std::ostream &

os = G4cout

)

const [virtual]

Definition at line 102 of file G4FCylindricalSurface.cc.

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

{ 
  os << "G4FCylindricalSurface with origin: " << origin << "\t"
     << "and axis: " << Position.GetAxis() << "\n"
     << "\t radius: " << radius << "\t and length: "
     << length << "\n";
}

void G4FCylindricalSurface::resize	(	G4double	r,
		G4double	l
	)			[virtual]

Definition at line 322 of file G4FCylindricalSurface.cc.

References G4endl, G4Exception(), JustWarning, length, and radius.

{
  //  Resize a G4FCylindricalSurface to a new radius r and new length l
  //  Require radius to be non-negative
  if ( r >= 0.0 )
    radius = r;
  else 
  {
    std::ostringstream message;
    message << "Negative radius." << G4endl
            << "Original value of " << radius << " is retained.";    
    G4Exception("G4FCylindricalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }

  //  Require length to be positive
  if ( l > 0.0 )
    length = l;
  else 
  {
    std::ostringstream message;
    message << "Negative or zero length." << G4endl
            << "Original value of " << length << " is retained.";    
    G4Exception("G4FCylindricalSurface::resize()",
                "GeomSolids1001", JustWarning, message);
  }
}

G4double G4FCylindricalSurface::Scale

(

)

const [virtual]

Definition at line 278 of file G4FCylindricalSurface.cc.

References length, and radius.

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

void G4FCylindricalSurface::SetRadius

(

G4double

r

)

G4Vector3D G4FCylindricalSurface::SurfaceNormal

(

const G4Point3D &

p

)

const [virtual]

Implements G4Surface.

Definition at line 290 of file G4FCylindricalSurface.cc.

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

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

  if( !sameSense )
    n = -n;
  
  return n;
}

G4int G4FCylindricalSurface::WithinBoundary

(

const G4Vector3D &

x

)

const [virtual]

Definition at line 266 of file G4FCylindricalSurface.cc.

References G4Axis2Placement3D::GetAxis(), G4Axis2Placement3D::GetLocation(), length, and Position.

{
  //  return 1 if point x is within the boundaries of the G4FCylindricalSurface
  //  return 0 otherwise (assume it is on the cylinder)
  if ( std::fabs( ( x - Position.GetLocation()) * Position.GetAxis() )
       <= 0.5 * length )
    return 1;
  else
    return 0;
}

---

Field Documentation

G4double G4FCylindricalSurface::length [protected]

Definition at line 154 of file G4FCylindricalSurface.hh.

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

G4Axis2Placement3D G4FCylindricalSurface::Position [protected]

Definition at line 152 of file G4FCylindricalSurface.hh.

Referenced by CalcBBox(), G4FCylindricalSurface(), GetAxis(), Intersect(), operator==(), PrintOn(), SurfaceNormal(), and WithinBoundary().

G4double G4FCylindricalSurface::radius [protected]

Definition at line 153 of file G4FCylindricalSurface.hh.

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

---

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

• G4FCylindricalSurface.hh
• G4FCylindricalSurface.icc
• G4FCylindricalSurface.cc

---