G4FPlane Class Reference

#include <G4FPlane.hh>

Inheritance diagram for G4FPlane:

Public Member Functions
	G4FPlane ()
virtual	~G4FPlane ()
	G4FPlane (const G4Vector3D &direction, const G4Vector3D &axis, const G4Point3D &Pt0, G4int sense=1)
	G4FPlane (const G4Point3DVector *pVec, const G4Point3DVector *iVec=0, G4int sense=1)
G4int	Intersect (const G4Ray &G4Rayref)
void	CalcBBox ()
void	Project ()
G4int	GetConvex () const
G4int	GetNumberOfPoints () const
G4Point3D	GetSrfPoint () const
const G4Point3D &	GetPoint (G4int Count) const
void	CalcNormal ()
G4Vector3D	SurfaceNormal (const G4Point3D &Pt) const
const char *	Name () const
G4double	ClosestDistanceToPoint (const G4Point3D &Pt)
G4double	HowNear (const G4Vector3D &x) const
G4Axis2Placement3D	GetPplace () const
G4Plane	GetPplane () const
G4int	MyType () const
G4int	IsConvex () const
void	Deactivate ()
G4Ray *	Norm ()
const G4Point3D &	GetHitPoint () 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 Member Functions
void	InitBounded ()
virtual void	InitBounded ()

Protected Attributes
G4Point3D	hitpoint
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)

Detailed Description

Definition at line 67 of file G4FPlane.hh.

Constructor & Destructor Documentation

G4FPlane() [1/3]

G4FPlane::G4FPlane

(

)

~G4FPlane()

G4FPlane::~G4FPlane ( )

virtual

Definition at line 124 of file G4FPlane.cc.

{
  delete NormalX;
}

G4FPlane() [2/3]

G4FPlane::G4FPlane	(	const G4Vector3D &	direction,
		const G4Vector3D &	axis,
		const G4Point3D &	Pt0,
		G4int	sense = 1
	)

Definition at line 49 of file G4FPlane.cc.

  : pplace(direction, axis, Pt0), Convex(0), projectedBoundary(0)
{
  G4Point3D Pt1 = G4Point3D( Pt0 + direction );
 
  // The plane include direction and axis is the normal,
  // so axis^direction is included in the plane
  G4Point3D Pt2 = G4Point3D( Pt0 + axis.cross(direction) );
 
  G4Ray::CalcPlane3Pts( Pl, Pt0, Pt1, Pt2 );
 
  active   = 1;
  sameSense = sense;
  CalcNormal();
  distance = kInfinity;
  Type     = 1;
}

G4FPlane() [3/3]

G4FPlane::G4FPlane	(	const G4Point3DVector *	pVec,
		const G4Point3DVector *	iVec = 0,
		G4int	sense = 1
	)

Definition at line 70 of file G4FPlane.cc.

  : pplace( (*pVec)[0]-(*pVec)[1],                    // direction
        ((*pVec)[pVec->size()-1]-(*pVec)[0])
        .cross((*pVec)[0]-(*pVec)[1]),            // axis
        (*pVec)[0]                             )  // location
 
{
  G4Ray::CalcPlane3Pts( Pl, (*pVec)[0], (*pVec)[1], (*pVec)[2] );
 
  G4CurveVector bounds;
  G4CompositeCurve* polygon;
 
  projectedBoundary = new G4SurfaceBoundary;
 
  sameSense = sense;
 
  // Outer boundary
 
  polygon= new G4CompositeCurve(*pVec);
 
  for (size_t i=0; i< polygon->GetSegments().size(); i++) 
    polygon->GetSegments()[i]->SetSameSense(sameSense);
 
  bounds.push_back(polygon);
  
  // Eventual inner boundary
  
  if (iVec) 
  {
    polygon= new G4CompositeCurve(*iVec);
 
    for (size_t i=0; i< polygon->GetSegments().size(); i++) 
    polygon->GetSegments()[i]->SetSameSense(sameSense);
 
    bounds.push_back(polygon);
  }
  
  // Set sense for boundaries  
  
  for (size_t j=0; j< bounds.size(); j++) 
    bounds[j]->SetSameSense(sameSense);
  
 
  SetBoundaries(&bounds);
      
  CalcNormal();
  IsConvex();
  distance = kInfinity;
  Type=1;
}

Member Function Documentation

CalcBBox()

void G4FPlane::CalcBBox ( )

virtual

Reimplemented from G4Surface.

Definition at line 130 of file G4FPlane.cc.

{
  // This is needed since the bounds are used for the Solid
  // bbox calculation. The bbox test is NOT performed for
  // planar surfaces.
 
  // Finds the bounds of the G4Plane surface iow
  // calculates the bounds for a bounding box
  // to the surface. The bounding box is used
  // for a preliminary check of intersection.
  
  bbox= new G4BoundingBox3D(surfaceBoundary.BBox().GetBoxMin(), 
                surfaceBoundary.BBox().GetBoxMax());
 
}

CalcNormal()

void G4FPlane::CalcNormal ( )

virtual

Reimplemented from G4Surface.

Definition at line 147 of file G4FPlane.cc.

{
/* 
  // Calc Normal for surface which is used for the projection
  // Make planes
  G4Vector3D norm;
 
  G4Vector3D RefDirection = pplace.GetRefDirection();
  G4Vector3D Axis = pplace.GetAxis();
 
  // L. Broglia : before in G4Placement
  if( RefDirection == Axis )
    norm = RefDirection;
  else
  {
    // L. Broglia : error on setY, and it`s better to use cross function
    // norm.setX( RefDirection.y() * Axis.z() -  RefDirection.z() * Axis.y() );
    // norm.setY( RefDirection.x() * Axis.z() -  RefDirection.z() * Axis.x() );
    // norm.setZ( RefDirection.x() * Axis.y() -  RefDirection.y() * Axis.x() );
       
    norm = RefDirection.cross(Axis);
  }
  
  //  const G4Point3D& tmp = pplace.GetSrfPoint();
  const G4Point3D tmp = pplace.GetLocation();
*/  
 
  // L. Broglia
  // The direction of the normal is the axis of his location
  // Its sense depend on the orientation of the bounded curve
  const G4Point3D tmp = pplace.GetLocation();
  G4Vector3D norm;
  G4int sense = GetSameSense();
  
  if (sense)
    norm = pplace.GetAxis();
  else
    norm = - pplace.GetAxis();
 
  NormalX =  new G4Ray(tmp, norm);
  NormalX->RayCheck();
  NormalX->CreatePlanes();
}

Referenced by G4FPlane().

ClosestDistanceToPoint()

G4double G4FPlane::ClosestDistanceToPoint ( const G4Point3D &  Pt )

virtual

Reimplemented from G4Surface.

Definition at line 341 of file G4FPlane.cc.

{
  // Calculates signed distance of point Pt to G4Plane Pl
  // Be careful, the equation of the plane is :
  // ax + by + cz = d
  G4double dist = Pt.x()*Pl.a + Pt.y()*Pl.b + Pt.z()*Pl.c - Pl.d;
 
  return dist;
}

Deactivate()

void G4FPlane::Deactivate ( )

inline

GetConvex()

G4int G4FPlane::GetConvex ( ) const

inlinevirtual

Reimplemented from G4Surface.

GetHitPoint()

const G4Point3D & G4FPlane::GetHitPoint ( ) const

inline

GetNumberOfPoints()

G4int G4FPlane::GetNumberOfPoints ( ) const

inlinevirtual

Reimplemented from G4Surface.

GetPoint()

const G4Point3D & G4FPlane::GetPoint ( G4int  Count ) const

inlinevirtual

Reimplemented from G4Surface.

GetPplace()

G4Axis2Placement3D G4FPlane::GetPplace ( ) const

inline

GetPplane()

G4Plane G4FPlane::GetPplane ( ) const

inline

GetSrfPoint()

G4Point3D G4FPlane::GetSrfPoint ( ) const

inline

Referenced by G4BREPSolidPolyhedra::SurfaceNormal().

HowNear()

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

virtual

Reimplemented from G4Surface.

Definition at line 360 of file G4FPlane.cc.

{
  G4double hownear = Pt.x()*Pl.a + Pt.y()*Pl.b + Pt.z()*Pl.c - Pl.d;
 
  return hownear;
}

InitBounded()

void G4FPlane::InitBounded ( )

protectedvirtual

Reimplemented from G4Surface.

Definition at line 352 of file G4FPlane.cc.

{
  // L. Broglia
 
  projectedBoundary =
    surfaceBoundary.Project( pplace.GetToPlacementCoordinates() );
}

Intersect()

G4int G4FPlane::Intersect ( const G4Ray &  G4Rayref )

virtual

Reimplemented from G4Surface.

Definition at line 210 of file G4FPlane.cc.

{
  // This function count the number of intersections of a 
  // bounded surface by a ray.
  
 
  // Find the intersection with the infinite plane
  Intersected =1;
 
  // s is solution, line is p + tq, n is G4Plane Normal, r is point on G4Plane 
  // all parameters are pointers to arrays of three elements
 
  hitpoint = PINFINITY;
  register G4double a, b, t;
 
  register const G4Vector3D& RayDir   = rayref.GetDir();
  register const G4Point3D&  RayStart = rayref.GetStart();
 
  G4double dirx =  RayDir.x();
  G4double diry =  RayDir.y();
  G4double dirz =  RayDir.z();
 
  G4Vector3D norm = (*NormalX).GetDir();
  G4Point3D  srf_point = pplace.GetLocation();
 
  b = norm.x() * dirx + norm.y() * diry + norm.z() * dirz;
 
  if ( std::fabs(b) < perMillion )    
  {
    // G4cout << "\nLine is parallel to G4Plane.No Hit.";
  }  
  else
  {
    G4double startx =  RayStart.x();
    G4double starty =  RayStart.y();
    G4double startz =  RayStart.z();    
    
    a = norm.x() * (srf_point.x() - startx) + 
        norm.y() * (srf_point.y() - starty) + 
        norm.z() * (srf_point.z() - startz)   ;
    
    t = a/b;
    
    // substitute t into line equation
    // to calculate final solution     
    G4double solx,soly,solz;
    solx = startx + t * dirx;
    soly = starty + t * diry;
    solz = startz + t * dirz;
 
    // solve tolerance problem
    if( (t*dirx >= -kCarTolerance/2) && (t*dirx <= kCarTolerance/2) )
      solx = startx;
 
    if( (t*diry >= -kCarTolerance/2) && (t*diry <= kCarTolerance/2) )
      soly = starty;
 
    if( (t*dirz >= -kCarTolerance/2) && (t*dirz <= kCarTolerance/2) )
      solz = startz;
    
    G4bool xhit = (dirx < 0 && solx <= startx) || (dirx >= 0 && solx >= startx);
    G4bool yhit = (diry < 0 && soly <= starty) || (diry >= 0 && soly >= starty);
    G4bool zhit = (dirz < 0 && solz <= startz) || (dirz >= 0 && solz >= startz);
    
    if( xhit && yhit && zhit ) {
      hitpoint= G4Point3D(solx, soly, solz);
    }
  }
   
  // closest_hit is a public Point3D in G4Surface
  closest_hit = hitpoint;
  
  if(closest_hit.x() == kInfinity)
  {
    // no hit
    active=0;
    SetDistance(kInfinity);
    return 0;
  }
  else
  {
    // calculate the squared distance from the point to the intersection
    // and set it in the distance data member (all clients know they have
    // to take the sqrt)
    SetDistance( RayStart.distance2(closest_hit) );   
 
    // now, we have to verify that the hit point founded
    // is included into the G4FPlane boundaries
 
    // project the hit to the xy plane,
    // with the same projection that took the boundary
    // into projectedBoundary
    G4Point3D projectedHit= pplace.GetToPlacementCoordinates() * closest_hit;
    
    // test ray from the hit on the xy plane
    G4Ray testRay( projectedHit, G4Vector3D(1, 0.01, 0) );
 
    // check if it intersects the boundary
    G4int nbinter = projectedBoundary->IntersectRay2D(testRay);
 
    // If this number is par, it`s signify that the projected point  
    // is outside the projected surface, so the hit point is outside
    // the bounded surface
    if(nbinter&1)
    {
      // the intersection point is into the boundaries
      // check if the intersection point is on the surface
      if(distance <= kCarTolerance*0.5*kCarTolerance*0.5)
      {
    // the point is on the surface, set the distance to 0            
    SetDistance(0);         
      }
      else
      {
    // the point is outside the surface
      }
      
      return 1 ;      
    }
    else
    {
      // the intersection point is out the boundaries
      // it is not a real intersection
      active=0;
      SetDistance(kInfinity);
      return 0;
    }
  }
}

IsConvex()

G4int G4FPlane::IsConvex ( ) const

virtual

Reimplemented from G4Surface.

Definition at line 204 of file G4FPlane.cc.

{
  return -1;  
}

Referenced by G4FPlane().

MyType()

G4int G4FPlane::MyType ( ) const

inlinevirtual

Reimplemented from G4Surface.

Name()

const char * G4FPlane::Name ( ) const

inlinevirtual

Reimplemented from G4Surface.

Norm()

G4Ray * G4FPlane::Norm ( )

inlinevirtual

Reimplemented from G4Surface.

Project()

void G4FPlane::Project ( )

virtual

Reimplemented from G4Surface.

Definition at line 192 of file G4FPlane.cc.

{
    // Project
    // const G4Plane& Plane1 = NormalX->GetPlane(1);
    // const G4Plane& Plane2 = NormalX->GetPlane(2);
 
    // probably not necessary
    // projections of the boundary should be handled by the intersection
    //    OuterBoundary->ProjectBoundaryTo2D(Plane1, Plane2, 0);
}

SurfaceNormal()

G4Vector3D G4FPlane::SurfaceNormal ( const G4Point3D &  Pt ) const

inlinevirtual

Implements G4Surface.

Referenced by G4BREPSolidPolyhedra::SurfaceNormal().

Member Data Documentation

hitpoint

G4Point3D G4FPlane::hitpoint

protected

Definition at line 151 of file G4FPlane.hh.

Referenced by Intersect().

---

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

• G4FPlane.hh
• G4FPlane.cc