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
Protected Member Functions
void	InitBounded ()
Protected Attributes
G4Point3D	hitpoint

---

Detailed Description

Definition at line 67 of file G4FPlane.hh.

---

Constructor & Destructor Documentation

G4FPlane::G4FPlane

(

)

G4FPlane::~G4FPlane

(

)

[virtual]

Definition at line 124 of file G4FPlane.cc.

{
  delete NormalX;
}

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

Definition at line 49 of file G4FPlane.cc.

References G4Surface::active, CalcNormal(), G4Ray::CalcPlane3Pts(), G4Surface::distance, G4Surface::sameSense, and G4Surface::Type.

  : 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::G4FPlane	(	const G4Point3DVector *	pVec,
		const G4Point3DVector *	iVec = 0,
		G4int	sense = 1
	)

Definition at line 70 of file G4FPlane.cc.

References CalcNormal(), G4Ray::CalcPlane3Pts(), G4Surface::distance, G4CompositeCurve::GetSegments(), IsConvex(), G4Surface::sameSense, G4Surface::SetBoundaries(), G4Surface::SetSameSense(), and G4Surface::Type.

  : 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

void G4FPlane::CalcBBox

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 130 of file G4FPlane.cc.

References G4SurfaceBoundary::BBox(), G4Surface::bbox, G4BoundingBox3D::GetBoxMax(), G4BoundingBox3D::GetBoxMin(), and G4Surface::surfaceBoundary.

{
  // 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());

}

void G4FPlane::CalcNormal

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 147 of file G4FPlane.cc.

References G4Ray::CreatePlanes(), G4Axis2Placement3D::GetAxis(), G4Axis2Placement3D::GetLocation(), G4Surface::GetSameSense(), and G4Ray::RayCheck().

Referenced by G4FPlane().

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

G4double G4FPlane::ClosestDistanceToPoint

(

const G4Point3D &

Pt

)

[virtual]

Reimplemented from G4Surface.

Definition at line 341 of file G4FPlane.cc.

References G4Plane::a, G4Plane::b, G4Plane::c, and G4Plane::d.

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

void G4FPlane::Deactivate

(

)

[inline]

Reimplemented from G4Surface.

Definition at line 44 of file G4FPlane.icc.

References G4Surface::active.

{
  active=0;
}

G4int G4FPlane::GetConvex

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 38 of file G4FPlane.icc.

{
  return Convex;
}

const G4Point3D & G4FPlane::GetHitPoint

(

)

const [inline]

Definition at line 68 of file G4FPlane.icc.

References hitpoint.

{
  return hitpoint;
}

G4int G4FPlane::GetNumberOfPoints

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 50 of file G4FPlane.icc.

References G4SurfaceBoundary::GetNumberOfPoints(), and G4Surface::surfaceBoundary.

{
  return (surfaceBoundary.GetNumberOfPoints());
}

const G4Point3D & G4FPlane::GetPoint

(

G4int

Count

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 62 of file G4FPlane.icc.

References G4SurfaceBoundary::GetPoint(), and G4Surface::surfaceBoundary.

{
  return surfaceBoundary.GetPoint(Count);
}  

G4Axis2Placement3D G4FPlane::GetPplace

(

)

const [inline]

Definition at line 92 of file G4FPlane.icc.

{
  return  pplace;
}

G4Plane G4FPlane::GetPplane

(

)

const [inline]

Definition at line 98 of file G4FPlane.icc.

{
  return  Pl;
}

G4Point3D G4FPlane::GetSrfPoint

(

)

const [inline]

Definition at line 56 of file G4FPlane.icc.

References G4Axis2Placement3D::GetLocation().

Referenced by G4BREPSolidPolyhedra::SurfaceNormal().

{
  return pplace.GetLocation();
}

G4double G4FPlane::HowNear

(

const G4Vector3D &

x

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 360 of file G4FPlane.cc.

References G4Plane::a, G4Plane::b, G4Plane::c, and G4Plane::d.

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

  return hownear;
}

void G4FPlane::InitBounded

(

)

[protected, virtual]

Reimplemented from G4Surface.

Definition at line 352 of file G4FPlane.cc.

References G4Axis2Placement3D::GetToPlacementCoordinates(), G4SurfaceBoundary::Project(), and G4Surface::surfaceBoundary.

{
  // L. Broglia

  projectedBoundary =
    surfaceBoundary.Project( pplace.GetToPlacementCoordinates() );
}

G4int G4FPlane::Intersect

(

const G4Ray &

G4Rayref

)

[virtual]

Reimplemented from G4Surface.

Definition at line 210 of file G4FPlane.cc.

References G4Surface::active, G4Surface::closest_hit, G4Surface::distance, G4Ray::GetDir(), G4Axis2Placement3D::GetLocation(), G4Ray::GetStart(), G4Axis2Placement3D::GetToPlacementCoordinates(), hitpoint, G4Surface::Intersected, G4SurfaceBoundary::IntersectRay2D(), G4Surface::kCarTolerance, PINFINITY(), and G4Surface::SetDistance().

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

G4int G4FPlane::IsConvex

(

)

const [virtual]

Reimplemented from G4Surface.

Definition at line 204 of file G4FPlane.cc.

Referenced by G4FPlane().

{
  return -1;  
}

G4int G4FPlane::MyType

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 104 of file G4FPlane.icc.

{
  return 1;
}

const char * G4FPlane::Name

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 86 of file G4FPlane.icc.

{
  return "G4FPlane";
}

G4Ray * G4FPlane::Norm

(

)

[inline, virtual]

Reimplemented from G4Surface.

Definition at line 74 of file G4FPlane.icc.

{
  return NormalX;
}

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

G4Vector3D G4FPlane::SurfaceNormal

(

const G4Point3D &

Pt

)

const [inline, virtual]

Implements G4Surface.

Definition at line 80 of file G4FPlane.icc.

References G4Ray::GetDir().

Referenced by G4BREPSolidPolyhedra::SurfaceNormal().

{
  return NormalX->GetDir();
}

---

Field Documentation

G4Point3D G4FPlane::hitpoint [protected]

Definition at line 151 of file G4FPlane.hh.

Referenced by GetHitPoint(), and Intersect().

---

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

• G4FPlane.hh
• G4FPlane.icc
• G4FPlane.cc

---