#include <G4TwistTrapFlatSide.hh>

Inheritance diagram for G4TwistTrapFlatSide:

Public Member Functions
	G4TwistTrapFlatSide (const G4String &name, G4double PhiTwist, G4double pDx1, G4double pDx2, G4double pDy, G4double pDz, G4double pAlpha, G4double pPhi, G4double pTheta, G4int handedness)

	~G4TwistTrapFlatSide () override

G4ThreeVector	GetNormal (const G4ThreeVector &, G4bool isGlobal=false) override

G4int	DistanceToSurface (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol) override

G4int	DistanceToSurface (const G4ThreeVector &gp, G4ThreeVector gxx[], G4double distance[], G4int areacode[]) override

G4ThreeVector	SurfacePoint (G4double x, G4double y, G4bool isGlobal=false) override

G4double	GetBoundaryMin (G4double u) override

G4double	GetBoundaryMax (G4double u) override

G4double	GetSurfaceArea () override

void	GetFacets (G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside) override

	G4TwistTrapFlatSide (__void__ &)

Public Member Functions inherited from G4VTwistSurface
	G4VTwistSurface (const G4String &name)

	G4VTwistSurface (const G4String &name, const G4RotationMatrix &rot, const G4ThreeVector &tlate, G4int handedness, const EAxis axis1, const EAxis axis2, G4double axis0min=-kInfinity, G4double axis1min=-kInfinity, G4double axis0max=kInfinity, G4double axis1max=kInfinity)

virtual	~G4VTwistSurface ()

virtual G4int	AmIOnLeftSide (const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)

virtual G4double	DistanceToBoundary (G4int areacode, G4ThreeVector &xx, const G4ThreeVector &p)

virtual G4double	DistanceToIn (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)

virtual G4double	DistanceToOut (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)

virtual G4double	DistanceTo (const G4ThreeVector &gp, G4ThreeVector &gxx)

void	DebugPrint () const

virtual G4String	GetName () const

virtual void	GetBoundaryParameters (const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const

virtual G4ThreeVector	GetBoundaryAtPZ (G4int areacode, const G4ThreeVector &p) const

G4double	DistanceToPlaneWithV (const G4ThreeVector &p, const G4ThreeVector &v, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)

G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)

G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &t1, const G4ThreeVector &t2, G4ThreeVector &xx, G4ThreeVector &n)

G4double	DistanceToLine (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &d, G4ThreeVector &xx)

G4bool	IsAxis0 (G4int areacode) const

G4bool	IsAxis1 (G4int areacode) const

G4bool	IsOutside (G4int areacode) const

G4bool	IsInside (G4int areacode, G4bool testbitmode=false) const

G4bool	IsBoundary (G4int areacode, G4bool testbitmode=false) const

G4bool	IsCorner (G4int areacode, G4bool testbitmode=false) const

G4bool	IsValidNorm () const

G4bool	IsSameBoundary (G4VTwistSurface surface1, G4int areacode1, G4VTwistSurface surface2, G4int areacode2) const

G4int	GetAxisType (G4int areacode, G4int whichaxis) const

G4ThreeVector	ComputeGlobalPoint (const G4ThreeVector &lp) const

G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &gp) const

G4ThreeVector	ComputeGlobalDirection (const G4ThreeVector &lp) const

G4ThreeVector	ComputeLocalDirection (const G4ThreeVector &gp) const

void	SetAxis (G4int i, const EAxis axis)

void	SetNeighbours (G4VTwistSurface ax0min, G4VTwistSurface ax1min, G4VTwistSurface ax0max, G4VTwistSurface ax1max)

G4int	GetNode (G4int i, G4int j, G4int m, G4int n, G4int iside)

G4int	GetFace (G4int i, G4int j, G4int m, G4int n, G4int iside)

G4int	GetEdgeVisibility (G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)

	G4VTwistSurface (__void__ &)

Protected Member Functions
G4int	GetAreaCode (const G4ThreeVector &xx, G4bool withTol=true) override

Protected Member Functions inherited from G4VTwistSurface
G4VTwistSurface **	GetNeighbours ()

G4int	GetNeighbours (G4int areacode, G4VTwistSurface *surfaces[])

G4ThreeVector	GetCorner (G4int areacode) const

void	GetBoundaryAxis (G4int areacode, EAxis axis[]) const

void	GetBoundaryLimit (G4int areacode, G4double limit[]) const

virtual void	SetBoundary (const G4int &axiscode, const G4ThreeVector &direction, const G4ThreeVector &x0, const G4int &boundarytype)

void	SetCorner (G4int areacode, G4double x, G4double y, G4double z)

Additional Inherited Members
Public Types inherited from G4VTwistSurface
enum	EValidate { kDontValidate = 0 , kValidateWithTol = 1 , kValidateWithoutTol = 2 , kUninitialized = 3 }

Static Public Attributes inherited from G4VTwistSurface
static const G4int	sOutside = 0x00000000

static const G4int	sInside = 0x10000000

static const G4int	sBoundary = 0x20000000

static const G4int	sCorner = 0x40000000

static const G4int	sC0Min1Min = 0x40000101

static const G4int	sC0Max1Min = 0x40000201

static const G4int	sC0Max1Max = 0x40000202

static const G4int	sC0Min1Max = 0x40000102

static const G4int	sAxisMin = 0x00000101

static const G4int	sAxisMax = 0x00000202

static const G4int	sAxisX = 0x00000404

static const G4int	sAxisY = 0x00000808

static const G4int	sAxisZ = 0x00000C0C

static const G4int	sAxisRho = 0x00001010

static const G4int	sAxisPhi = 0x00001414

static const G4int	sAxis0 = 0x0000FF00

static const G4int	sAxis1 = 0x000000FF

static const G4int	sSizeMask = 0x00000303

static const G4int	sAxisMask = 0x0000FCFC

static const G4int	sAreaMask = 0XF0000000

Protected Attributes inherited from G4VTwistSurface
EAxis	fAxis [2]

G4double	fAxisMin [2]

G4double	fAxisMax [2]

CurrentStatus	fCurStatWithV

CurrentStatus	fCurStat

G4RotationMatrix	fRot

G4ThreeVector	fTrans

G4int	fHandedness

G4SurfCurNormal	fCurrentNormal

G4bool	fIsValidNorm

G4double	kCarTolerance

Detailed Description

Definition at line 39 of file G4TwistTrapFlatSide.hh.

Constructor & Destructor Documentation

◆ G4TwistTrapFlatSide() [1/2]

G4TwistTrapFlatSide::G4TwistTrapFlatSide	(	const G4String &	name,
		G4double	PhiTwist,
		G4double	pDx1,
		G4double	pDx2,
		G4double	pDy,
		G4double	pDz,
		G4double	pAlpha,
		G4double	pPhi,
		G4double	pTheta,
		G4int	handedness )

Definition at line 36 of file G4TwistTrapFlatSide.cc.

  : G4VTwistSurface(name)
{
   fHandedness = handedness;   // +z = +ve, -z = -ve
 
   fDx1 = pDx1 ;
   fDx2 = pDx2 ;
   fDy = pDy ;
   fDz = pDz ;
   fAlpha = pAlpha ;
   fTAlph = std::tan(fAlpha) ;
   fPhi  = pPhi ;
   fTheta = pTheta ;
 
   fdeltaX = 2 * fDz * std::tan(fTheta) * std::cos(fPhi)  ;
     // dx in surface equation
   fdeltaY = 2 * fDz * std::tan(fTheta) * std::sin(fPhi)  ;
     // dy in surface equation
 
   fPhiTwist = PhiTwist ;
 
   fCurrentNormal.normal.set( 0, 0, (fHandedness < 0 ? -1 : 1)); 
         // Unit vector, in local coordinate system
   fRot.rotateZ( fHandedness > 0 
                 ? 0.5 * fPhiTwist
                 : -0.5 * fPhiTwist );
 
   fTrans.set(
              fHandedness > 0 ? 0.5*fdeltaX : -0.5*fdeltaX , 
              fHandedness > 0 ? 0.5*fdeltaY : -0.5*fdeltaY ,
              fHandedness > 0 ? fDz : -fDz ) ;
 
   fIsValidNorm = true;
 
 
   fAxis[0] = kXAxis ;
   fAxis[1] = kYAxis ;
   fAxisMin[0] = kInfinity ;  // x-Axis cannot be fixed, because it 
   fAxisMax[0] =  kInfinity ; // depends on y
   fAxisMin[1] = -fDy ;  // y - axis
   fAxisMax[1] =  fDy ;
 
   SetCorners();
   SetBoundaries();
}

◆ ~G4TwistTrapFlatSide()

G4TwistTrapFlatSide::~G4TwistTrapFlatSide ( )

overridedefault

◆ G4TwistTrapFlatSide() [2/2]

G4TwistTrapFlatSide::G4TwistTrapFlatSide ( __void__ & a )

Definition at line 95 of file G4TwistTrapFlatSide.cc.

  : G4VTwistSurface(a)
{
}

Member Function Documentation

◆ DistanceToSurface() [1/2]

G4int G4TwistTrapFlatSide::DistanceToSurface	(	const G4ThreeVector &	gp,
		const G4ThreeVector &	gv,
		G4ThreeVector	gxx[],
		G4double	distance[],
		G4int	areacode[],
		G4bool	isvalid[],
		EValidate	validate = kValidateWithTol )

overridevirtual

Implements G4VTwistSurface.

Definition at line 125 of file G4TwistTrapFlatSide.cc.

{
   fCurStatWithV.ResetfDone(validate, &gp, &gv);
   
   if (fCurStatWithV.IsDone())
   {
      for (G4int i=0; i<fCurStatWithV.GetNXX(); ++i)
      {
         gxx[i] = fCurStatWithV.GetXX(i);
         distance[i] = fCurStatWithV.GetDistance(i);
         areacode[i] = fCurStatWithV.GetAreacode(i);
         isvalid[i]  = fCurStatWithV.IsValid(i);
      }
      return fCurStatWithV.GetNXX();
   }
   else   // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         isvalid[i]  = false;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
 
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector v = ComputeLocalDirection(gv);
 
   //
   // special case!
   // if p is on surface, distance = 0. 
   //
 
   if (std::fabs(p.z()) == 0.)     // if p is on the plane
   {
      distance[0] = 0;
      G4ThreeVector xx = p;
      gxx[0] = ComputeGlobalPoint(xx);
      
      if (validate == kValidateWithTol)
      {
         areacode[0] = GetAreaCode(xx);
         if (!IsOutside(areacode[0]))
         {
            isvalid[0] = true;
         }
      }
      else if (validate == kValidateWithoutTol)
      {
         areacode[0] = GetAreaCode(xx, false);
         if (IsInside(areacode[0]))
         {
            isvalid[0] = true;
         }
      }
      else   // kDontValidate
      {
         areacode[0] = sInside;
         isvalid[0] = true;
      }
      return 1;
   }
   //
   // special case end
   //
   
   if (v.z() == 0) { 
 
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0], 
                                     isvalid[0], 0, validate, &gp, &gv);
      return 0;
   }
   
   distance[0] = - (p.z() / v.z());
      
   G4ThreeVector xx = p + distance[0]*v;
   gxx[0] = ComputeGlobalPoint(xx);
 
   if (validate == kValidateWithTol)
   {
      areacode[0] = GetAreaCode(xx);
      if (!IsOutside(areacode[0]))
      {
         if (distance[0] >= 0) isvalid[0] = true;
      }
   }
   else if (validate == kValidateWithoutTol)
   {
      areacode[0] = GetAreaCode(xx, false);
      if (IsInside(areacode[0]))
      {
         if (distance[0] >= 0) isvalid[0] = true;
      }
   }
   else   // kDontValidate
   {
      areacode[0] = sInside;
         if (distance[0] >= 0) isvalid[0] = true;
   }
 
   fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                  isvalid[0], 1, validate, &gp, &gv);
 
#ifdef G4TWISTDEBUG
   G4cerr << "ERROR - G4TwistTrapFlatSide::DistanceToSurface(p,v)" << G4endl;
   G4cerr << "        Name        : " << GetName() << G4endl;
   G4cerr << "        xx          : " << xx << G4endl;
   G4cerr << "        gxx[0]      : " << gxx[0] << G4endl;
   G4cerr << "        dist[0]     : " << distance[0] << G4endl;
   G4cerr << "        areacode[0] : " << areacode[0] << G4endl;
   G4cerr << "        isvalid[0]  : " << isvalid[0]  << G4endl;
#endif
   return 1;
}

◆ DistanceToSurface() [2/2]

G4int G4TwistTrapFlatSide::DistanceToSurface	(	const G4ThreeVector &	gp,
		G4ThreeVector	gxx[],
		G4double	distance[],
		G4int	areacode[] )

overridevirtual

Implements G4VTwistSurface.

Definition at line 250 of file G4TwistTrapFlatSide.cc.

{
   // Calculate distance to plane in local coordinate,
   // then return distance and global intersection points.
   //  
 
   fCurStat.ResetfDone(kDontValidate, &gp);
 
   if (fCurStat.IsDone())
   {
      for (G4int i=0; i<fCurStat.GetNXX(); ++i)
      {
         gxx[i] = fCurStat.GetXX(i);
         distance[i] = fCurStat.GetDistance(i);
         areacode[i] = fCurStat.GetAreacode(i);
      }
      return fCurStat.GetNXX();
   }
   else  // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
   
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector xx;
 
   // The plane is placed on origin with making its normal 
   // parallel to z-axis. 
   if (std::fabs(p.z()) <= 0.5 * kCarTolerance)
   {   // if p is on the plane, return 1
      distance[0] = 0;
      xx = p;
   }
   else
   {
      distance[0] = std::fabs(p.z());
      xx.set(p.x(), p.y(), 0);  
   }
 
   gxx[0] = ComputeGlobalPoint(xx);
   areacode[0] = sInside;
   G4bool isvalid = true;
   fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                             isvalid, 1, kDontValidate, &gp);
   return 1;
 
}

◆ GetAreaCode()

G4int G4TwistTrapFlatSide::GetAreaCode	(	const G4ThreeVector &	xx,
		G4bool	withTol = true )

overrideprotectedvirtual

Implements G4VTwistSurface.

Definition at line 309 of file G4TwistTrapFlatSide.cc.

{
 
  static const G4double ctol = 0.5 * kCarTolerance;
  G4int areacode = sInside;
  
  if (fAxis[0] == kXAxis && fAxis[1] == kYAxis)
  {
    G4int yaxis = 1;
    
    G4double wmax = xAxisMax(xx.y(), fTAlph ) ;
    G4double wmin = -xAxisMax(xx.y(), -fTAlph ) ;
 
    if (withTol)
    {
      G4bool isoutside   = false;
      
      // test boundary of x-axis
      
      if (xx.x() < wmin + ctol)
      {
        areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary; 
        if (xx.x() <= wmin - ctol) isoutside = true;
        
      }
      else if (xx.x() > wmax - ctol)
      {
        areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
        if (xx.x() >= wmax + ctol)  isoutside = true;
      }
      
      // test boundary of y-axis
      
      if (xx.y() < fAxisMin[yaxis] + ctol)
      {
        areacode |= (sAxis1 & (sAxisY | sAxisMin)); 
        
        if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner.
        else                        areacode |= sBoundary;
        if (xx.y() <= fAxisMin[yaxis] - ctol) isoutside = true;
        
      }
      else if (xx.y() > fAxisMax[yaxis] - ctol)
      {
        areacode |= (sAxis1 & (sAxisY | sAxisMax));
        
        if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner.
        else                        areacode |= sBoundary; 
        if (xx.y() >= fAxisMax[yaxis] + ctol) isoutside = true;
      }
      
      // if isoutside = true, clear inside bit.             
      // if not on boundary, add axis information.             
      
      if (isoutside)
      {
        G4int tmpareacode = areacode & (~sInside);
        areacode = tmpareacode;
      }
      else if ((areacode & sBoundary) != sBoundary)
      {
        areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisY);
      }           
    }
    else
    {
      // boundary of x-axis
 
      if (xx.x() < wmin )
      {
        areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary;
      }
      else if (xx.x() > wmax)
      {
        areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
      }
      
      // boundary of y-axis
      
      if (xx.y() < fAxisMin[yaxis])
      {
        areacode |= (sAxis1 & (sAxisY | sAxisMin));
        if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner.
        else                        areacode |= sBoundary; 
        
      }
      else if (xx.y() > fAxisMax[yaxis])
      {
        areacode |= (sAxis1 & (sAxisY | sAxisMax)) ;
        if   ((areacode & sBoundary) != 0) areacode |= sCorner;  // xx is on corner.
        else                        areacode |= sBoundary; 
      }
      
      if ((areacode & sBoundary) != sBoundary)
      {
        areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisY);
      }           
    }
    return areacode;
  }
  else
  {
    G4Exception("G4TwistTrapFlatSide::GetAreaCode()",
                "GeomSolids0001", FatalException,
                "Feature NOT implemented !");
  }
  
  return areacode;
}

Referenced by DistanceToSurface().

◆ GetBoundaryMax()

G4double G4TwistTrapFlatSide::GetBoundaryMax ( G4double u )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 136 of file G4TwistTrapFlatSide.hh.

{
  return xAxisMax(y, fTAlph) ; 
}

Referenced by GetFacets().

◆ GetBoundaryMin()

G4double G4TwistTrapFlatSide::GetBoundaryMin ( G4double u )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 130 of file G4TwistTrapFlatSide.hh.

{
  return -xAxisMax(y, -fTAlph) ;
}

Referenced by GetFacets().

◆ GetFacets()

void G4TwistTrapFlatSide::GetFacets	(	G4int	m,
		G4int	n,
		G4double	xyz[][3],
		G4int	faces[][4],
		G4int	iside )

overridevirtual

Implements G4VTwistSurface.

Definition at line 518 of file G4TwistTrapFlatSide.cc.

{
  G4double x,y    ;     // the two parameters for the surface equation
  G4ThreeVector p ;  // a point on the surface, given by (z,u)
 
  G4int nnode ;
  G4int nface ;
 
  G4double xmin,xmax ;
 
  // calculate the (n-1)*(k-1) vertices
 
  for ( G4int i = 0 ; i<n ; ++i )
  {
    y = -fDy + i*(2*fDy)/(n-1) ;
 
    for ( G4int j = 0 ; j<k ; ++j )
    {
      xmin = GetBoundaryMin(y) ;
      xmax = GetBoundaryMax(y) ;
      x = xmin + j*(xmax-xmin)/(k-1) ;
 
      nnode = GetNode(i,j,k,n,iside) ;
      p = SurfacePoint(x,y,true) ;  // surface point in global coordinate system
 
      xyz[nnode][0] = p.x() ;
      xyz[nnode][1] = p.y() ;
      xyz[nnode][2] = p.z() ;
 
      if ( i<n-1 && j<k-1 )
      {
        nface = GetFace(i,j,k,n,iside) ;
 
        if (fHandedness < 0)  // lower side
        {
          faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,1)
                          * ( GetNode(i  ,j  ,k,n,iside)+1) ;  
          faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,1)
                          * ( GetNode(i+1,j  ,k,n,iside)+1) ;
          faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,1)
                          * ( GetNode(i+1,j+1,k,n,iside)+1) ;
          faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,1)
                          * ( GetNode(i  ,j+1,k,n,iside)+1) ;
        }
        else                  // upper side
        {
          faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,-1)
                          * ( GetNode(i  ,j  ,k,n,iside)+1) ;  
          faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,-1)
                          * ( GetNode(i  ,j+1,k,n,iside)+1) ;
          faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,-1)
                          * ( GetNode(i+1,j+1,k,n,iside)+1) ;
          faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,-1)
                          * ( GetNode(i+1,j  ,k,n,iside)+1) ;
        }
      }
    }
  }
}

◆ GetNormal()

G4ThreeVector G4TwistTrapFlatSide::GetNormal	(	const G4ThreeVector &	,
		G4bool	isGlobal = false )

overridevirtual

Implements G4VTwistSurface.

Definition at line 109 of file G4TwistTrapFlatSide.cc.

{
   if (isGlobal)
   {
      return ComputeGlobalDirection(fCurrentNormal.normal);
   }
   else
   {
      return fCurrentNormal.normal;
   }
}

◆ GetSurfaceArea()

G4double G4TwistTrapFlatSide::GetSurfaceArea ( )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 142 of file G4TwistTrapFlatSide.hh.

{
  return 2*(fDx1 + fDx2)*fDy ;
}

◆ SurfacePoint()

G4ThreeVector G4TwistTrapFlatSide::SurfacePoint	(	G4double	x,
		G4double	y,
		G4bool	isGlobal = false )

inlineoverridevirtual

Implements G4VTwistSurface.

Definition at line 121 of file G4TwistTrapFlatSide.hh.

{
  G4ThreeVector SurfPoint ( x,y,0);
 
  if (isGlobal) { return (fRot*SurfPoint + fTrans); }
  return SurfPoint;
}

Referenced by GetFacets().

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4TwistTrapFlatSide() [1/2]

◆ ~G4TwistTrapFlatSide()

◆ G4TwistTrapFlatSide() [2/2]

Member Function Documentation

◆ DistanceToSurface() [1/2]

◆ DistanceToSurface() [2/2]

◆ GetAreaCode()

◆ GetBoundaryMax()

◆ GetBoundaryMin()

◆ GetFacets()

◆ GetNormal()

◆ GetSurfaceArea()

◆ SurfacePoint()