G4TriangularFacet Class Reference

G4TriangularFacet defines a facet with 3 vertices, used for the contruction of G4TessellatedSolid. Vertices shall be supplied in anti-clockwise order looking from the outsider of the solid where it belongs. More...

#include <G4TriangularFacet.hh>

Inheritance diagram for G4TriangularFacet:

Public Member Functions
	G4TriangularFacet ()
	G4TriangularFacet (const G4ThreeVector &Pt0, const G4ThreeVector &vt1, const G4ThreeVector &vt2, G4FacetVertexType vType)
	~G4TriangularFacet () override
	G4TriangularFacet (const G4TriangularFacet &right)
	G4TriangularFacet (G4TriangularFacet &&right) noexcept
G4TriangularFacet &	operator= (const G4TriangularFacet &right)
G4TriangularFacet &	operator= (G4TriangularFacet &&right) noexcept
G4VFacet *	GetClone () override
G4TriangularFacet *	GetFlippedFacet ()
G4ThreeVector	Distance (const G4ThreeVector &p)
G4double	Distance (const G4ThreeVector &p, G4double minDist) override
G4double	Distance (const G4ThreeVector &p, G4double minDist, const G4bool outgoing) override
G4double	Extent (const G4ThreeVector axis) override
G4bool	Intersect (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool outgoing, G4double &distance, G4double &distFromSurface, G4ThreeVector &normal) override
G4double	GetArea () const override
G4ThreeVector	GetPointOnFace () const override
G4ThreeVector	GetSurfaceNormal () const override
void	SetSurfaceNormal (const G4ThreeVector &normal)
G4GeometryType	GetEntityType () const override
G4bool	IsDefined () const override
G4int	GetNumberOfVertices () const override
G4ThreeVector	GetVertex (G4int i) const override
void	SetVertex (G4int i, const G4ThreeVector &val) override
void	SetVertices (std::vector< G4ThreeVector > *v) override
G4double	GetRadius () const override
G4ThreeVector	GetCircumcentre () const override
G4int	AllocatedMemory () override
G4int	GetVertexIndex (G4int i) const override
void	SetVertexIndex (G4int i, G4int j) override
Public Member Functions inherited from G4VFacet
	G4VFacet ()
virtual	~G4VFacet ()=default
G4bool	operator== (const G4VFacet &right) const
void	ApplyTranslation (const G4ThreeVector &v)
std::ostream &	StreamInfo (std::ostream &os) const
G4bool	IsInside (const G4ThreeVector &p) const

Additional Inherited Members
Protected Attributes inherited from G4VFacet
G4double	kCarTolerance
Static Protected Attributes inherited from G4VFacet
static const G4double	dirTolerance = 1.0E-14

Detailed Description

G4TriangularFacet defines a facet with 3 vertices, used for the contruction of G4TessellatedSolid. Vertices shall be supplied in anti-clockwise order looking from the outsider of the solid where it belongs.

Definition at line 65 of file G4TriangularFacet.hh.

Constructor & Destructor Documentation

G4TriangularFacet() [1/4]

G4TriangularFacet::G4TriangularFacet

(

)

Default Constructor.

Definition at line 145 of file G4TriangularFacet.cc.

{
  fVertices = new vector<G4ThreeVector>(3);
  G4ThreeVector zero(0,0,0);
  SetVertex(0, zero);
  SetVertex(1, zero);
  SetVertex(2, zero);
  for (G4int i = 0; i < 3; ++i)
  {
    fIndices[i] = -1;
  }
  fIsDefined = false;
  fSurfaceNormal.set(0,0,0);
  fA = fB = fC = 0;
  fE1 = zero;
  fE2 = zero;
  fDet = 0.0;
  fArea = fRadius = 0.0;
}

Referenced by G4TriangularFacet(), G4TriangularFacet(), GetClone(), GetFlippedFacet(), operator=(), operator=(), and SetVertexIndex().

G4TriangularFacet() [2/4]

G4TriangularFacet::G4TriangularFacet	(	const G4ThreeVector &	Pt0,
		const G4ThreeVector &	vt1,
		const G4ThreeVector &	vt2,
		G4FacetVertexType	vType )

Constructs a facet with 3 vertices, given its parameters.

Parameters

[in]	Pt0	The anchor point, first vertex.
[in]	vt1	Second vertex.
[in]	vt2	Third vertex.
[in]	vType	The positioning type for the vertices, either: "ABSOLUTE" - vertices set in anti-clockwise order when looking from the outsider. "RELATIVE" - first vertex is Pt0, second is Pt0+vt1, and the third vertex is Pt0+vt2, still in anti-clockwise order.

Definition at line 55 of file G4TriangularFacet.cc.

{
  fVertices = new vector<G4ThreeVector>(3);
 
  SetVertex(0, vt0);
  if (vertexType == ABSOLUTE)
  {
    SetVertex(1, vt1);
    SetVertex(2, vt2);
    fE1 = vt1 - vt0;
    fE2 = vt2 - vt0;
  }
  else
  {
    SetVertex(1, vt0 + vt1);
    SetVertex(2, vt0 + vt2);
    fE1 = vt1;
    fE2 = vt2;
  }
 
  G4ThreeVector E1xE2 = fE1.cross(fE2);
  fArea = 0.5 * E1xE2.mag();
  for (G4int i = 0; i < 3; ++i)
  {
    fIndices[i] = -1;
  }
 
  fIsDefined = true;
  G4double delta = kCarTolerance; // Set tolerance for checking
 
  // Check length of edges
  //
  G4double leng1 = fE1.mag();
  G4double leng2 = (fE2-fE1).mag();
  G4double leng3 = fE2.mag();
  if (leng1 <= delta || leng2 <= delta || leng3 <= delta) 
  {
    fIsDefined = false;
  }
 
  // Check min height of triangle
  //
  if (fIsDefined)
  {
    if (2.*fArea/std::max(std::max(leng1,leng2),leng3) <= delta)
    {
      fIsDefined = false;
    } 
  }
 
  // Define facet
  //
  if (!fIsDefined)
  {
    ostringstream message;
    message << "Facet is too small or too narrow." << G4endl
            << "Triangle area = " << fArea << G4endl
            << "P0 = " << GetVertex(0) << G4endl
            << "P1 = " << GetVertex(1) << G4endl
            << "P2 = " << GetVertex(2) << G4endl
            << "Side1 length (P0->P1) = " << leng1 << G4endl
            << "Side2 length (P1->P2) = " << leng2 << G4endl
            << "Side3 length (P2->P0) = " << leng3;
    G4Exception("G4TriangularFacet::G4TriangularFacet()",
        "GeomSolids1001", JustWarning, message);
    fSurfaceNormal.set(0,0,0);
    fA = fB = fC = 0.0;
    fDet = 0.0;
    fCircumcentre = vt0 + 0.5*fE1 + 0.5*fE2;
    fArea = fRadius = 0.0;
  }
  else
  { 
    fSurfaceNormal = E1xE2.unit();
    fA   = fE1.mag2();
    fB   = fE1.dot(fE2);
    fC   = fE2.mag2();
    fDet = std::fabs(fA*fC - fB*fB);
 
    fCircumcentre = 
      vt0 + (E1xE2.cross(fE1)*fC + fE2.cross(E1xE2)*fA) / (2.*E1xE2.mag2());
    fRadius = (fCircumcentre - vt0).mag();
  }
}

~G4TriangularFacet()

G4TriangularFacet::~G4TriangularFacet ( )

override

Destructor.

Definition at line 167 of file G4TriangularFacet.cc.

{
  SetVertices(nullptr);
}

G4TriangularFacet() [3/4]

G4TriangularFacet::G4TriangularFacet

(

const G4TriangularFacet &

right

)

Copy and move constructors.

Definition at line 209 of file G4TriangularFacet.cc.

  : G4VFacet(rhs)
{
  CopyFrom(rhs);
}

G4TriangularFacet() [4/4]

G4TriangularFacet::G4TriangularFacet ( G4TriangularFacet && right )

noexcept

Definition at line 217 of file G4TriangularFacet.cc.

  : G4VFacet(rhs)
{
  MoveFrom(rhs);
}

Member Function Documentation

AllocatedMemory()

G4int G4TriangularFacet::AllocatedMemory ( )

inlineoverridevirtual

Returns the allocated memory (sizeof) by the facet.

Implements G4VFacet.

Distance() [1/3]

G4ThreeVector G4TriangularFacet::Distance

(

const G4ThreeVector &

p

)

Determines the vector between p and the closest point on the facet to p.

Definition at line 296 of file G4TriangularFacet.cc.

{
  G4ThreeVector D  = GetVertex(0) - p;
  G4double d = fE1.dot(D);
  G4double e = fE2.dot(D);
  G4double f = D.mag2();
  G4double q = fB*e - fC*d;
  G4double t = fB*d - fA*e;
  fSqrDist = 0.;
 
  if (q+t <= fDet)
  {
    if (q < 0.0)
    {
      if (t < 0.0)
      {
        //
        // We are in region 4.
        //
        if (d < 0.0)
        {
          t = 0.0;
          if (-d >= fA) {q = 1.0; fSqrDist = fA + 2.0*d + f;}
          else         {q = -d/fA; fSqrDist = d*q + f;}
        }
        else
        {
          q = 0.0;
          if       (e >= 0.0) {t = 0.0; fSqrDist = f;}
          else if (-e >= fC)   {t = 1.0; fSqrDist = fC + 2.0*e + f;}
          else                {t = -e/fC; fSqrDist = e*t + f;}
        }
      }
      else
      {
        //
        // We are in region 3.
        //
        q = 0.0;
        if      (e >= 0.0) {t = 0.0; fSqrDist = f;}
        else if (-e >= fC)  {t = 1.0; fSqrDist = fC + 2.0*e + f;}
        else               {t = -e/fC; fSqrDist = e*t + f;}
      }
    }
    else if (t < 0.0)
    {
      //
      // We are in region 5.
      //
      t = 0.0;
      if      (d >= 0.0) {q = 0.0; fSqrDist = f;}
      else if (-d >= fA)  {q = 1.0; fSqrDist = fA + 2.0*d + f;}
      else               {q = -d/fA; fSqrDist = d*q + f;}
    }
    else
    {
      //
      // We are in region 0.
      //
      G4double dist = fSurfaceNormal.dot(D);
      fSqrDist = dist*dist;
      return fSurfaceNormal*dist;
    }
  }
  else
  {
    if (q < 0.0)
    {
      //
      // We are in region 2.
      //
      G4double tmp0 = fB + d;
      G4double tmp1 = fC + e;
      if (tmp1 > tmp0)
      {
        G4double numer = tmp1 - tmp0;
        G4double denom = fA - 2.0*fB + fC;
        if (numer >= denom) {q = 1.0; t = 0.0; fSqrDist = fA + 2.0*d + f;}
        else
        {
          q       = numer/denom;
          t       = 1.0 - q;
          fSqrDist = q*(fA*q + fB*t +2.0*d) + t*(fB*q + fC*t + 2.0*e) + f;
        }
      }
      else
      {
        q = 0.0;
        if      (tmp1 <= 0.0) {t = 1.0; fSqrDist = fC + 2.0*e + f;}
        else if (e >= 0.0)    {t = 0.0; fSqrDist = f;}
        else                  {t = -e/fC; fSqrDist = e*t + f;}
      }
    }
    else if (t < 0.0)
    {
      //
      // We are in region 6.
      //
      G4double tmp0 = fB + e;
      G4double tmp1 = fA + d;
      if (tmp1 > tmp0)
      {
        G4double numer = tmp1 - tmp0;
        G4double denom = fA - 2.0*fB + fC;
        if (numer >= denom) {t = 1.0; q = 0.0; fSqrDist = fC + 2.0*e + f;}
        else
        {
          t       = numer/denom;
          q       = 1.0 - t;
          fSqrDist = q*(fA*q + fB*t +2.0*d) + t*(fB*q + fC*t + 2.0*e) + f;
        }
      }
      else
      {
        t = 0.0;
        if      (tmp1 <= 0.0) {q = 1.0; fSqrDist = fA + 2.0*d + f;}
        else if (d >= 0.0)    {q = 0.0; fSqrDist = f;}
        else                  {q = -d/fA; fSqrDist = d*q + f;}
      }
    }
    else
      //
      // We are in region 1.
      //
    {
      G4double numer = fC + e - fB - d;
      if (numer <= 0.0)
      {
        q       = 0.0;
        t       = 1.0;
        fSqrDist = fC + 2.0*e + f;
      }
      else
      {
        G4double denom = fA - 2.0*fB + fC;
        if (numer >= denom) {q = 1.0; t = 0.0; fSqrDist = fA + 2.0*d + f;}
        else
        {
          q       = numer/denom;
          t       = 1.0 - q;
          fSqrDist = q*(fA*q + fB*t + 2.0*d) + t*(fB*q + fC*t + 2.0*e) + f;
        }
      }
    }
  } 
  //
  //
  // Do fA check for rounding errors in the distance-squared.  It appears that
  // the conventional methods for calculating fSqrDist breaks down when very
  // near to or at the surface (as required by transport).
  // We'll therefore also use the magnitude-squared of the vector displacement.
  // (Note that I've also tried to get around this problem by using the
  // existing equations for
  //
  //    fSqrDist = function(fA,fB,fC,d,q,t)
  //
  // and use fA more accurate addition process which minimises errors and
  // breakdown of cummutitivity [where (A+B)+C != A+(B+C)] but this still
  // doesn't work.
  // Calculation from u = D + q*fE1 + t*fE2 is less efficient, but appears
  // more robust.
  //
  if (fSqrDist < 0.0) { fSqrDist = 0.; }
  G4ThreeVector u = D + q*fE1 + t*fE2;
  G4double u2 = u.mag2();
  //
  // The following (part of the roundoff error check) is from Oliver Merle'q
  // updates.
  //
  if (fSqrDist > u2) { fSqrDist = u2; }
 
  return u;
}

Referenced by Distance(), Distance(), and Intersect().

Distance() [2/3]

G4double G4TriangularFacet::Distance ( const G4ThreeVector & p, G4double minDist )

overridevirtual

Determines the closest distance between point p and the facet.

Implements G4VFacet.

Definition at line 480 of file G4TriangularFacet.cc.

{
  //
  // Start with quicky test to determine if the surface of the sphere enclosing
  // the triangle is any closer to p than minDist.  If not, then don't bother
  // about more accurate test.
  //
  G4double dist = kInfinity;
  if ((p-fCircumcentre).mag()-fRadius < minDist)
  {
    //
    // It's possible that the triangle is closer than minDist,
    // so do more accurate assessment.
    //
    dist = Distance(p).mag();
  }
  return dist;
}

Distance() [3/3]

G4double G4TriangularFacet::Distance ( const G4ThreeVector & p, G4double minDist, const G4bool outgoing )

overridevirtual

Determines the distance to point 'p'. kInfinity is returned if either: (1) outgoing is TRUE and the dot product of the normal vector to the facet and the displacement vector from p to the triangle is negative. (2) outgoing is FALSE and the dot product of the normal vector to the facet and the displacement vector from p to the triangle is positive.

Implements G4VFacet.

Definition at line 515 of file G4TriangularFacet.cc.

{
  //
  // Start with quicky test to determine if the surface of the sphere enclosing
  // the triangle is any closer to p than minDist.  If not, then don't bother
  // about more accurate test.
  //
  G4double dist = kInfinity;
  if ((p-fCircumcentre).mag()-fRadius < minDist)
  {
    //
    // It's possible that the triangle is closer than minDist,
    // so do more accurate assessment.
    //
    G4ThreeVector v  = Distance(p);
    G4double dist1 = sqrt(fSqrDist);
    G4double dir = v.dot(fSurfaceNormal);
    G4bool wrongSide = (dir > 0.0 && !outgoing) || (dir < 0.0 && outgoing);
    if (dist1 <= kCarTolerance)
    {
      //
      // Point p is very close to triangle.  Check if it's on the wrong side,
      // in which case return distance of 0.0 otherwise .
      //
      if (wrongSide)
      {
        dist = 0.0;
      }
      else
      {
        dist = dist1;
      }
    }
    else if (!wrongSide)
    {
      dist = dist1;
    }
  }
  return dist;
}

Extent()

G4double G4TriangularFacet::Extent ( const G4ThreeVector axis )

overridevirtual

Calculates the furthest the triangle extends in fA particular direction defined by the vector axis.

Implements G4VFacet.

Definition at line 565 of file G4TriangularFacet.cc.

{
  G4double ss = GetVertex(0).dot(axis);
  G4double sp = GetVertex(1).dot(axis);
  if (sp > ss) { ss = sp; }
  sp = GetVertex(2).dot(axis);
  if (sp > ss) { ss = sp; }
  return ss;
}

GetArea()

G4double G4TriangularFacet::GetArea ( ) const

overridevirtual

Auxiliary method for returning the surface area.

Implements G4VFacet.

Definition at line 801 of file G4TriangularFacet.cc.

{
  return fArea;
}

GetCircumcentre()

G4ThreeVector G4TriangularFacet::GetCircumcentre ( ) const

inlineoverridevirtual

Returns the circumcentre point of the facet.

Implements G4VFacet.

GetClone()

G4VFacet * G4TriangularFacet::GetClone ( )

overridevirtual

Returns a pointer to a newly allocated duplicate copy of the facet.

Implements G4VFacet.

Definition at line 261 of file G4TriangularFacet.cc.

{
  auto fc = new G4TriangularFacet (GetVertex(0), GetVertex(1),
                                   GetVertex(2), ABSOLUTE);
  return fc;
}

GetEntityType()

G4GeometryType G4TriangularFacet::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4TriangularFacet" of the facet.

Implements G4VFacet.

Definition at line 808 of file G4TriangularFacet.cc.

{
  return "G4TriangularFacet";
}

GetFlippedFacet()

G4TriangularFacet * G4TriangularFacet::GetFlippedFacet

(

)

Generates and returns an identical facet, but with the normal vector pointing at 180 degrees.

Definition at line 275 of file G4TriangularFacet.cc.

{
  auto flipped = new G4TriangularFacet (GetVertex(0), GetVertex(1),
                                        GetVertex(2), ABSOLUTE);
  return flipped;
}

GetNumberOfVertices()

G4int G4TriangularFacet::GetNumberOfVertices ( ) const

inlineoverridevirtual

Returns the number of vertices, i.e. 3.

Implements G4VFacet.

GetPointOnFace()

G4ThreeVector G4TriangularFacet::GetPointOnFace ( ) const

overridevirtual

Auxiliary method to get a uniform random point on the facet.

Implements G4VFacet.

Definition at line 783 of file G4TriangularFacet.cc.

{
  G4double u = G4QuickRand();
  G4double v = G4QuickRand();
  if (u + v > 1.)
  {
    u = 1. - u;
    v = 1. - v;
  }
  return GetVertex(0) + u*fE1 + v*fE2;
}

GetRadius()

G4double G4TriangularFacet::GetRadius ( ) const

inlineoverridevirtual

Returns the radius to the anchor point and centered on the circumcentre.

Implements G4VFacet.

GetSurfaceNormal()

G4ThreeVector G4TriangularFacet::GetSurfaceNormal ( ) const

overridevirtual

Returns/sets the normal vector to the facet.

Implements G4VFacet.

Definition at line 815 of file G4TriangularFacet.cc.

{
  return fSurfaceNormal;
}

GetVertex()

G4ThreeVector G4TriangularFacet::GetVertex ( G4int i ) const

inlineoverridevirtual

Returns the vertex based on the index 'i'.

Implements G4VFacet.

Referenced by Distance(), Extent(), G4TriangularFacet(), GetClone(), GetFlippedFacet(), GetPointOnFace(), and Intersect().

GetVertexIndex()

G4int G4TriangularFacet::GetVertexIndex ( G4int i ) const

inlineoverridevirtual

Accessor/setter for the vertex index.

Implements G4VFacet.

Intersect()

G4bool G4TriangularFacet::Intersect ( const G4ThreeVector & p, const G4ThreeVector & v, const G4bool outgoing, G4double & distance, G4double & distFromSurface, G4ThreeVector & normal )

overridevirtual

Finds the next intersection when going from 'p' in the direction of 'v'. If 'outgoing' is true, only consider the face if we are going out through the face; otherwise, if false, only consider the face if we are going in through the face.

Returns

true if there is an intersection, false otherwise.

Implements G4VFacet.

Definition at line 602 of file G4TriangularFacet.cc.

{
  //
  // Check whether the direction of the facet is consistent with the vector v
  // and the need to be outgoing or ingoing.  If inconsistent, disregard and
  // return false.
  //
  G4double w = v.dot(fSurfaceNormal);
  if ((outgoing && w < -dirTolerance) || (!outgoing && w > dirTolerance))
  {
    distance = kInfinity;
    distFromSurface = kInfinity;
    normal.set(0,0,0);
    return false;
  } 
  //
  // Calculate the orthogonal distance from p to the surface containing the
  // triangle.  Then determine if we're on the right or wrong side of the
  // surface (at fA distance greater than kCarTolerance to be consistent with
  // "outgoing".
  //
  const G4ThreeVector& p0 = GetVertex(0);
  G4ThreeVector D  = p0 - p;
  distFromSurface  = D.dot(fSurfaceNormal);
  G4bool wrongSide = (outgoing && distFromSurface < -0.5*kCarTolerance) ||
    (!outgoing && distFromSurface >  0.5*kCarTolerance);
 
  if (wrongSide)
  {
    distance = kInfinity;
    distFromSurface = kInfinity;
    normal.set(0,0,0);
    return false;
  }
 
  wrongSide = (outgoing && distFromSurface < 0.0)
           || (!outgoing && distFromSurface > 0.0);
  if (wrongSide)
  {
    //
    // We're slightly on the wrong side of the surface.  Check if we're close
    // enough using fA precise distance calculation.
    //
    G4ThreeVector u = Distance(p);
    if (fSqrDist <= kCarTolerance*kCarTolerance)
    {
      //
      // We're very close.  Therefore return fA small negative number
      // to pretend we intersect.
      //
      // distance = -0.5*kCarTolerance
      distance = 0.0;
      normal = fSurfaceNormal;
      return true;
    }
    
    //
    // We're close to the surface containing the triangle, but sufficiently
    // far from the triangle, and on the wrong side compared to the directions
    // of the surface normal and v.  There is no intersection.
    //
    distance = kInfinity;
    distFromSurface = kInfinity;
    normal.set(0,0,0);
    return false;
  }
  if (w < dirTolerance && w > -dirTolerance)
  {
    //
    // The ray is within the plane of the triangle. Project the problem into 2D
    // in the plane of the triangle. First try to create orthogonal unit vectors
    // mu and nu, where mu is fE1/|fE1|.  This is kinda like
    // the original algorithm due to Rickard Holmberg, but with better
    // mathematical justification than the original method ... however,
    // beware Rickard's was less time-consuming.
    //
    // Note that vprime is not fA unit vector.  We need to keep it unnormalised
    // since the values of distance along vprime (s0 and s1) for intersection
    // with the triangle will be used to determine if we cut the plane at the
    // same time.
    //
    G4ThreeVector mu = fE1.unit();
    G4ThreeVector nu = fSurfaceNormal.cross(mu);
    G4TwoVector pprime(p.dot(mu), p.dot(nu));
    G4TwoVector vprime(v.dot(mu), v.dot(nu));
    G4TwoVector P0prime(p0.dot(mu), p0.dot(nu));
    G4TwoVector E0prime(fE1.mag(), 0.0);
    G4TwoVector E1prime(fE2.dot(mu), fE2.dot(nu));
    G4TwoVector loc[2];
    if (G4TessellatedGeometryAlgorithms::IntersectLineAndTriangle2D(pprime,
                                    vprime, P0prime, E0prime, E1prime, loc))
    {
      //
      // There is an intersection between the line and triangle in 2D.
      // Now check which part of the line intersects with the plane
      // containing the triangle in 3D.
      //
      G4double vprimemag = vprime.mag();
      G4double s0        = (loc[0] - pprime).mag()/vprimemag;
      G4double s1        = (loc[1] - pprime).mag()/vprimemag;
      G4double normDist0 = fSurfaceNormal.dot(s0*v) - distFromSurface;
      G4double normDist1 = fSurfaceNormal.dot(s1*v) - distFromSurface;
 
      if ((normDist0 < 0.0 && normDist1 < 0.0)
       || (normDist0 > 0.0 && normDist1 > 0.0)
       || (normDist0 == 0.0 && normDist1 == 0.0) ) 
      {
        distance        = kInfinity;
        distFromSurface = kInfinity;
        normal.set(0,0,0);
        return false;
      }
      
      G4double dnormDist = normDist1 - normDist0;
      if (fabs(dnormDist) < DBL_EPSILON)
      {
        distance = s0;
        normal   = fSurfaceNormal;
        if (!outgoing) { distFromSurface = -distFromSurface; }
        return true;
      }
      
      distance = s0 - normDist0*(s1-s0)/dnormDist;
      normal   = fSurfaceNormal;
      if (!outgoing) { distFromSurface = -distFromSurface; }
      return true;
    }
    distance = kInfinity;
    distFromSurface = kInfinity;
    normal.set(0,0,0);
    return false;
  }
  //
  //
  // Use conventional algorithm to determine the whether there is an
  // intersection.  This involves determining the point of intersection of the
  // line with the plane containing the triangle, and then calculating if the
  // point is within the triangle.
  //
  distance = distFromSurface / w;
  G4ThreeVector pp = p + v*distance;
  G4ThreeVector DD = p0 - pp;
  G4double d = fE1.dot(DD);
  G4double e = fE2.dot(DD);
  G4double ss = fB*e - fC*d;
  G4double t = fB*d - fA*e;
 
  G4double sTolerance = (fabs(fB)+ fabs(fC) + fabs(d) + fabs(e))*kCarTolerance;
  G4double tTolerance = (fabs(fA)+ fabs(fB) + fabs(d) + fabs(e))*kCarTolerance;
  G4double detTolerance = (fabs(fA)+ fabs(fC) + 2*fabs(fB) )*kCarTolerance;
 
  //if (ss < 0.0 || t < 0.0 || ss+t > fDet)
  if (ss < -sTolerance || t < -tTolerance || ( ss+t - fDet ) > detTolerance)
  {
    //
    // The intersection is outside of the triangle.
    //
    distance = distFromSurface = kInfinity;
    normal.set(0,0,0);
    return false;
  }
  
  //
  // There is an intersection.  Now we only need to set the surface normal.
  //
  normal = fSurfaceNormal;
  if (!outgoing) { distFromSurface = -distFromSurface; }
  return true;
}

IsDefined()

G4bool G4TriangularFacet::IsDefined ( ) const

inlineoverridevirtual

Returns true if the facet is defined.

Implements G4VFacet.

operator=() [1/2]

G4TriangularFacet & G4TriangularFacet::operator=

(

const G4TriangularFacet &

right

)

Assignment and move assignment operators.

Definition at line 226 of file G4TriangularFacet.cc.

{
  SetVertices(nullptr);
 
  if (this != &rhs)
  {
    delete fVertices;
    CopyFrom(rhs);
  }
 
  return *this;
}

operator=() [2/2]

G4TriangularFacet & G4TriangularFacet::operator= ( G4TriangularFacet && right )

noexcept

Definition at line 242 of file G4TriangularFacet.cc.

{
  SetVertices(nullptr);
 
  if (this != &rhs)
  {
    delete fVertices;
    MoveFrom(rhs);
  }
 
  return *this;
}

SetSurfaceNormal()

void G4TriangularFacet::SetSurfaceNormal

(

const G4ThreeVector &

normal

)

Definition at line 822 of file G4TriangularFacet.cc.

{
  fSurfaceNormal = normal;
}

SetVertex()

void G4TriangularFacet::SetVertex ( G4int i, const G4ThreeVector & val )

inlineoverridevirtual

Methods to set the vertices.

Implements G4VFacet.

Referenced by G4TriangularFacet(), and G4TriangularFacet().

SetVertexIndex()

void G4TriangularFacet::SetVertexIndex ( G4int i, G4int j )

inlineoverridevirtual

Implements G4VFacet.

SetVertices()

void G4TriangularFacet::SetVertices ( std::vector< G4ThreeVector > * v )

inlineoverridevirtual

Implements G4VFacet.

Referenced by operator=(), operator=(), and ~G4TriangularFacet().

---

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

• G4TriangularFacet.hh
• G4TriangularFacet.cc