G4QuadrangularFacet Class Reference

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

#include <G4QuadrangularFacet.hh>

Inheritance diagram for G4QuadrangularFacet:

Public Member Functions
	G4QuadrangularFacet (const G4ThreeVector &Pt0, const G4ThreeVector &vt1, const G4ThreeVector &vt2, const G4ThreeVector &vt3, G4FacetVertexType vType)
	~G4QuadrangularFacet () override=default
	G4QuadrangularFacet (const G4QuadrangularFacet &right)
G4QuadrangularFacet &	operator= (const G4QuadrangularFacet &right)
G4VFacet *	GetClone () override
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
G4ThreeVector	GetSurfaceNormal () const override
G4double	GetArea () const override
G4ThreeVector	GetPointOnFace () const override
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
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

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

Definition at line 68 of file G4QuadrangularFacet.hh.

Constructor & Destructor Documentation

G4QuadrangularFacet() [1/2]

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

Constructs a facet with 4 vertices, given its parameters.

Parameters

[in]	Pt0	The anchor point, first vertex.
[in]	vt1	Second vertex.
[in]	vt2	Third vertex.
[in]	vt3	Fourth 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, third vertex is Pt0+vt2 and fourth is Pt0+vt3, still in anti-clockwise order.

Definition at line 50 of file G4QuadrangularFacet.cc.

{
  G4double delta   =  1.0 * kCarTolerance; // dimension tolerance
  G4double epsilon = 0.01 * kCarTolerance; // planarity tolerance
 
  G4ThreeVector e1, e2, e3;
  SetVertex(0, vt0);
  if (vertexType == ABSOLUTE)
  {
    SetVertex(1, vt1);
    SetVertex(2, vt2);
    SetVertex(3, vt3);
 
    e1 = vt1 - vt0;
    e2 = vt2 - vt0;
    e3 = vt3 - vt0;
  }
  else
  {
    SetVertex(1, vt0 + vt1);
    SetVertex(2, vt0 + vt2);
    SetVertex(3, vt0 + vt3);
 
    e1 = vt1;
    e2 = vt2;
    e3 = vt3;
  }
 
  // Check length of sides and diagonals
  //
  G4double leng1 = e1.mag();
  G4double leng2 = (e2-e1).mag();
  G4double leng3 = (e3-e2).mag();
  G4double leng4 = e3.mag();
 
  G4double diag1 = e2.mag();
  G4double diag2 = (e3-e1).mag();
 
  if (leng1 <= delta || leng2 <= delta || leng3 <= delta || leng4 <= delta ||
      diag1 <= delta || diag2 <= delta)
  {
    ostringstream message;
    message << "Sides/diagonals of facet are too small." << G4endl
            << "P0 = " << GetVertex(0) << G4endl
            << "P1 = " << GetVertex(1) << G4endl
            << "P2 = " << GetVertex(2) << G4endl
            << "P3 = " << GetVertex(3) << G4endl
            << "Side1 length (P0->P1) = " << leng1 << G4endl
            << "Side2 length (P1->P2) = " << leng2 << G4endl
            << "Side3 length (P2->P3) = " << leng3 << G4endl
            << "Side4 length (P3->P0) = " << leng4 << G4endl
            << "Diagonal1 length (P0->P2) = " << diag1 << G4endl
            << "Diagonal2 length (P1->P3) = " << diag2;
    G4Exception("G4QuadrangularFacet::G4QuadrangularFacet()",
                "GeomSolids1001", JustWarning, message);
    return;
  }
 
  // Check that vertices are not collinear
  //
  G4double s1 = (e1.cross(e2)).mag()*0.5;
  G4double s2 = ((e2-e1).cross(e3-e2)).mag()*0.5;
  G4double s3 = (e2.cross(e3)).mag()*0.5;
  G4double s4 = (e1.cross(e3)).mag()*0.5;
 
  G4double h1 = 2.*s1 / std::max(std::max(leng1,leng2),diag1);
  G4double h2 = 2.*s2 / std::max(std::max(leng2,leng3),diag2);
  G4double h3 = 2.*s3 / std::max(std::max(leng3,leng4),diag1);
  G4double h4 = 2.*s4 / std::max(std::max(leng4,leng1),diag2);
   
  if (h1 <= delta || h2 <= delta || h3 <= delta || h4 <= delta )
  {
    ostringstream message;
    message << "Facet has three or more collinear vertices." << G4endl
            << "P0 = " << GetVertex(0) << G4endl
            << "P1 = " << GetVertex(1) << G4endl
            << "P2 = " << GetVertex(2) << G4endl
            << "P3 = " << GetVertex(3) << G4endl
            << "Smallest heights:" << G4endl
            << "  in triangle P0-P1-P2 = " << h1 << G4endl
            << "  in triangle P1-P2-P3 = " << h2 << G4endl
            << "  in triangle P2-P3-P0 = " << h3 << G4endl
            << "  in triangle P3-P0-P1 = " << h4;
    G4Exception("G4QuadrangularFacet::G4QuadrangularFacet()",
            "GeomSolids1001", JustWarning, message);
    return;
  }
 
  // Check that vertices are coplanar by computing minimal
  // height of tetrahedron comprising of vertices
  //
  G4double smax = std::max( std::max(s1,s2), std::max(s3,s4) ); 
  G4double hmin = 0.5 * std::fabs( e1.dot(e2.cross(e3)) ) / smax;
  if (hmin >= epsilon)
  {
    ostringstream message;
    message << "Facet is not planar." << G4endl
            << "Disrepancy = " << hmin << G4endl
            << "P0 = " << GetVertex(0) << G4endl
            << "P1 = " << GetVertex(1) << G4endl
            << "P2 = " << GetVertex(2) << G4endl
            << "P3 = " << GetVertex(3);
    G4Exception("G4QuadrangularFacet::G4QuadrangularFacet()",
            "GeomSolids1001", JustWarning, message);
    return;
  }
  
  // Check that facet is convex by computing crosspoint 
  // of diagonals
  //
  G4ThreeVector normal = e2.cross(e3-e1);
  G4double s = kInfinity, t = kInfinity, magnitude2 = normal.mag2();
  if (magnitude2 > delta*delta) // check: magnitude2 != 0.
  {
    s = normal.dot(e1.cross(e3-e1)) / magnitude2;
    t = normal.dot(e1.cross(e2))    / magnitude2;
  }
  if (s <= 0. || s >= 1. || t <= 0. || t >= 1.)
  {
    ostringstream message;
    message << "Facet is not convex." << G4endl
            << "Parameters of crosspoint of diagonals: "
            << s << " and " << t << G4endl
            << "should both be within (0,1) range" << G4endl
        << "P0 = " << GetVertex(0) << G4endl
        << "P1 = " << GetVertex(1) << G4endl
        << "P2 = " << GetVertex(2) << G4endl
        << "P3 = " << GetVertex(3);
    G4Exception("G4QuadrangularFacet::G4QuadrangularFacet()",
            "GeomSolids1001", JustWarning, message);
    return;
  }
 
  // Define facet
  //
  fFacet1 = G4TriangularFacet(GetVertex(0),GetVertex(1),GetVertex(2),ABSOLUTE);
  fFacet2 = G4TriangularFacet(GetVertex(0),GetVertex(2),GetVertex(3),ABSOLUTE);
 
  normal = normal.unit();
  fFacet1.SetSurfaceNormal(normal);
  fFacet2.SetSurfaceNormal(normal);
  
  G4ThreeVector vtmp = 0.5 * (e1 + e2);
  fCircumcentre = GetVertex(0) + vtmp;
  G4double radiusSqr = vtmp.mag2();
  fRadius = std::sqrt(radiusSqr);
  // 29.02.2016 Remark by E.Tcherniaev: computation
  // of fCircumcenter and fRadius is wrong, however
  // it did not create any problem till now.
  // Bizarre! Need to investigate!
}

Referenced by G4QuadrangularFacet(), GetClone(), operator=(), and ~G4QuadrangularFacet().

~G4QuadrangularFacet()

G4QuadrangularFacet::~G4QuadrangularFacet ( )

overridedefault

Default Destructor.

G4QuadrangularFacet() [2/2]

G4QuadrangularFacet::G4QuadrangularFacet

(

const G4QuadrangularFacet &

right

)

Copy constructor and assignment operator.

Definition at line 208 of file G4QuadrangularFacet.cc.

  : G4VFacet(rhs)
{
  fFacet1 = rhs.fFacet1;
  fFacet2 = rhs.fFacet2;
  fRadius = 0.0;
}

Member Function Documentation

Distance() [1/3]

G4ThreeVector G4QuadrangularFacet::Distance

(

const G4ThreeVector &

p

)

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

Definition at line 241 of file G4QuadrangularFacet.cc.

{
  G4ThreeVector v1 = fFacet1.Distance(p);
  G4ThreeVector v2 = fFacet2.Distance(p);
 
  if (v1.mag2() < v2.mag2())
  {
    return v1;
  }
  return v2;
}

Referenced by Distance(), and Distance().

Distance() [2/3]

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

overridevirtual

Determines the closest distance between point p and the facet.

Implements G4VFacet.

Definition at line 255 of file G4QuadrangularFacet.cc.

{  
  G4double dist = Distance(p).mag();
  return dist;
}

Distance() [3/3]

G4double G4QuadrangularFacet::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 264 of file G4QuadrangularFacet.cc.

{
  G4double dist;
 
  G4ThreeVector v = Distance(p);
  G4double dir = v.dot(GetSurfaceNormal());
  if ( ((dir > dirTolerance) && (!outgoing))
    || ((dir < -dirTolerance) && outgoing))
  {
    dist = kInfinity;
  }
  else
  { 
    dist = v.mag();
  }
  return dist;
}

Extent()

G4double G4QuadrangularFacet::Extent ( const G4ThreeVector axis )

overridevirtual

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

Implements G4VFacet.

Definition at line 285 of file G4QuadrangularFacet.cc.

{
  G4double ss  = 0;
 
  for (G4int i = 0; i <= 3; ++i)
  {
    G4double sp = GetVertex(i).dot(axis);
    if (sp > ss) { ss = sp; }
  }
  return ss;
}

GetArea()

G4double G4QuadrangularFacet::GetArea ( ) const

overridevirtual

Auxiliary method for returning the surface area.

Implements G4VFacet.

Definition at line 337 of file G4QuadrangularFacet.cc.

{
  G4double area = fFacet1.GetArea() + fFacet2.GetArea();
  return area;
}

GetCircumcentre()

G4ThreeVector G4QuadrangularFacet::GetCircumcentre ( ) const

inlineoverridevirtual

Returns the circumcentre point of the facet.

Implements G4VFacet.

GetClone()

G4VFacet * G4QuadrangularFacet::GetClone ( )

overridevirtual

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

Implements G4VFacet.

Definition at line 232 of file G4QuadrangularFacet.cc.

{
  auto c = new G4QuadrangularFacet (GetVertex(0), GetVertex(1),
                                    GetVertex(2), GetVertex(3), ABSOLUTE);
  return c;
}

GetEntityType()

G4String G4QuadrangularFacet::GetEntityType ( ) const

overridevirtual

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

Implements G4VFacet.

Definition at line 345 of file G4QuadrangularFacet.cc.

{
  return "G4QuadrangularFacet";
}

GetNumberOfVertices()

G4int G4QuadrangularFacet::GetNumberOfVertices ( ) const

inlineoverridevirtual

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

Implements G4VFacet.

GetPointOnFace()

G4ThreeVector G4QuadrangularFacet::GetPointOnFace ( ) const

overridevirtual

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

Implements G4VFacet.

Definition at line 324 of file G4QuadrangularFacet.cc.

{
  G4double s1 = fFacet1.GetArea();
  G4double s2 = fFacet2.GetArea();
  return ((s1 + s2)*G4QuickRand() < s1)
         ? fFacet1.GetPointOnFace()
         : fFacet2.GetPointOnFace();
}

GetRadius()

G4double G4QuadrangularFacet::GetRadius ( ) const

inlineoverridevirtual

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

Implements G4VFacet.

GetSurfaceNormal()

G4ThreeVector G4QuadrangularFacet::GetSurfaceNormal ( ) const

overridevirtual

Returns the normal vector to the face.

Implements G4VFacet.

Definition at line 352 of file G4QuadrangularFacet.cc.

{
  return fFacet1.GetSurfaceNormal();
}

Referenced by Distance().

GetVertex()

G4ThreeVector G4QuadrangularFacet::GetVertex ( G4int i ) const

inlineoverridevirtual

Returns the vertex based on the index 'i'.

Implements G4VFacet.

Referenced by Extent(), G4QuadrangularFacet(), and GetClone().

Intersect()

G4bool G4QuadrangularFacet::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 299 of file G4QuadrangularFacet.cc.

{
  G4bool intersect =
    fFacet1.Intersect(p,v,outgoing,distance,distFromSurface,normal);
  if (!intersect)
  {
    intersect = fFacet2.Intersect(p,v,outgoing,distance,distFromSurface,normal);
  }
  if (!intersect)
  {
    distance = distFromSurface = kInfinity;
    normal.set(0,0,0);
  }
  return intersect;
}

IsDefined()

G4bool G4QuadrangularFacet::IsDefined ( ) const

inlineoverridevirtual

Returns true if the facet is defined.

Implements G4VFacet.

operator=()

G4QuadrangularFacet & G4QuadrangularFacet::operator=

(

const G4QuadrangularFacet &

right

)

Definition at line 219 of file G4QuadrangularFacet.cc.

{
  if (this == &rhs) {  return *this; }
 
  fFacet1 = rhs.fFacet1;
  fFacet2 = rhs.fFacet2;
  fRadius = 0.0;
 
  return *this;
}

SetVertex()

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

inlineoverridevirtual

Methods to set the vertices.

Implements G4VFacet.

Referenced by G4QuadrangularFacet().

SetVertices()

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

inlineoverridevirtual

Implements G4VFacet.

---

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

• G4QuadrangularFacet.hh
• G4QuadrangularFacet.cc