G4Tet is a tetrahedra solid, defined by 4 points in space. More...

#include <G4Tet.hh>

Inheritance diagram for G4Tet:

Public Member Functions
	G4Tet (const G4String &pName, const G4ThreeVector &anchor, const G4ThreeVector &p2, const G4ThreeVector &p3, const G4ThreeVector &p4, G4bool *degeneracyFlag=nullptr)
	~G4Tet () override
void	SetVertices (const G4ThreeVector &anchor, const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3, G4bool *degeneracyFlag=nullptr)
void	GetVertices (G4ThreeVector &anchor, G4ThreeVector &p1, G4ThreeVector &p2, G4ThreeVector &p3) const
std::vector< G4ThreeVector >	GetVertices () const
G4bool	CheckDegeneracy (const G4ThreeVector &p0, const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3) const
void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep) override
void	SetBoundingLimits (const G4ThreeVector &pMin, const G4ThreeVector &pMax)
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=nullptr, G4ThreeVector n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
G4GeometryType	GetEntityType () const override
G4bool	IsFaceted () const override
G4VSolid *	Clone () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4ThreeVector	GetPointOnSurface () const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
	G4Tet (__void__ &)
	G4Tet (const G4Tet &rhs)
G4Tet &	operator= (const G4Tet &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual G4int	GetNumOfConstituents () const
void	DumpInfo () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Additional Inherited Members
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

G4Tet is a tetrahedra solid, defined by 4 points in space.

Definition at line 59 of file G4Tet.hh.

Constructor & Destructor Documentation

◆ G4Tet() [1/3]

G4Tet::G4Tet	(	const G4String &	pName,
		const G4ThreeVector &	anchor,
		const G4ThreeVector &	p2,
		const G4ThreeVector &	p3,
		const G4ThreeVector &	p4,
		G4bool *	degeneracyFlag = nullptr )

Constructs a tetrahedra, given its parameters.

Parameters

[in]	pName	The solid name.
[in]	anchor	The anchor point.
[in]	p2	Point 2.
[in]	p3	Point 3.
[in]	p4	Point 4.
[in]	degeneracyFlag	Flag indicating degeneracy of points.

Definition at line 66 of file G4Tet.cc.

  : G4VSolid(pName)
{
  // Check for degeneracy
  G4bool degenerate = CheckDegeneracy(p0, p1, p2, p3);
  if (degeneracyFlag != nullptr)
  {
    *degeneracyFlag = degenerate;
  }
  else if (degenerate)
  {
    std::ostringstream message;
    message << "Degenerate tetrahedron: " << GetName() << " !\n"
            << "  anchor: " << p0 << "\n"
            << "  p1    : " << p1 << "\n"
            << "  p2    : " << p2 << "\n"
            << "  p3    : " << p3 << "\n"
            << "  volume: "
            << std::abs((p1 - p0).cross(p2 - p0).dot(p3 - p0))/6.;
    G4Exception("G4Tet::G4Tet()", "GeomSolids0002", FatalException, message);
  }
 
  // Define surface thickness
  halfTolerance = 0.5 * kCarTolerance;
 
  // Set data members
  Initialize(p0, p1, p2, p3);
}

Referenced by Clone(), G4Tet(), and operator=().

◆ ~G4Tet()

G4Tet::~G4Tet ( )

override

Destructor.

Definition at line 113 of file G4Tet.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

◆ G4Tet() [2/3]

G4Tet::G4Tet ( __void__ & a )

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 104 of file G4Tet.cc.

  : G4VSolid(a)
{
}

◆ G4Tet() [3/3]

G4Tet::G4Tet ( const G4Tet & rhs )

Copy constructor and assignment operator.

Definition at line 122 of file G4Tet.cc.

  : G4VSolid(rhs)
{
   halfTolerance = rhs.halfTolerance;
   fCubicVolume = rhs.fCubicVolume;
   fSurfaceArea = rhs.fSurfaceArea;
   for (G4int i = 0; i < 4; ++i) { fVertex[i] = rhs.fVertex[i]; }
   for (G4int i = 0; i < 4; ++i) { fNormal[i] = rhs.fNormal[i]; }
   for (G4int i = 0; i < 4; ++i) { fDist[i] = rhs.fDist[i]; }
   for (G4int i = 0; i < 4; ++i) { fArea[i] = rhs.fArea[i]; }
   fBmin = rhs.fBmin;
   fBmax = rhs.fBmax;
}

Member Function Documentation

◆ BoundingLimits()

void G4Tet::BoundingLimits	(	G4ThreeVector &	pMin,
		G4ThreeVector &	pMax ) const

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 363 of file G4Tet.cc.

{
  pMin = fBmin;
  pMax = fBmax;
}

Referenced by CalculateExtent().

◆ CalculateExtent()

G4bool G4Tet::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pmin,
		G4double &	pmax ) const

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns: True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 373 of file G4Tet.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Check bounding box (bbox)
  //
  BoundingLimits(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
 
  // Use simple bounding-box to help in the case of complex 3D meshes
  //
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
 
#if 0
  // Precise extent computation (disabled by default for this shape)
  //
  G4bool exist;
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return exist = (pMin < pMax) ? true : false;
  }
 
  // Set bounding envelope (benv) and calculate extent
  //
  std::vector<G4ThreeVector> vec = GetVertices();
 
  G4ThreeVectorList anchor(1);
  anchor[0].set(vec[0].x(),vec[0].y(),vec[0].z());
 
  G4ThreeVectorList base(3);
  base[0].set(vec[1].x(),vec[1].y(),vec[1].z());
  base[1].set(vec[2].x(),vec[2].y(),vec[2].z());
  base[2].set(vec[3].x(),vec[3].y(),vec[3].z());
 
  std::vector<const G4ThreeVectorList *> polygons(2);
  polygons[0] = &anchor;
  polygons[1] = &base;
 
  G4BoundingEnvelope benv(bmin,bmax,polygons);
  return exists = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
#endif
}

◆ CheckDegeneracy()

G4bool G4Tet::CheckDegeneracy	(	const G4ThreeVector &	p0,
		const G4ThreeVector &	p1,
		const G4ThreeVector &	p2,
		const G4ThreeVector &	p3 ) const

Checks if the tetrahedron is degenerate. A tetrahedron is considered as degenerate in case its minimal height is less than the degeneracy tolerance

Returns: true if the tetrahedron is degenerate.

Definition at line 173 of file G4Tet.cc.

{
  G4double hmin = 4. * kCarTolerance; // degeneracy tolerance
 
  // Calculate volume
  G4double vol = std::abs((p1 - p0).cross(p2 - p0).dot(p3 - p0));
 
  // Calculate face areas squared
  G4double ss[4];
  ss[0] = ((p1 - p0).cross(p2 - p0)).mag2();
  ss[1] = ((p2 - p0).cross(p3 - p0)).mag2();
  ss[2] = ((p3 - p0).cross(p1 - p0)).mag2();
  ss[3] = ((p2 - p1).cross(p3 - p1)).mag2();
 
  // Find face with max area
  G4int k = 0;
  for (G4int i = 1; i < 4; ++i)
  {
    if (ss[i] > ss[k]) { k = i; }
  }
 
  // Check: vol^2 / s^2 <= hmin^2
  return (vol*vol <= ss[k]*hmin*hmin);
}

Referenced by G4Tet(), and SetVertices().

◆ Clone()

G4VSolid * G4Tet::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns: A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 611 of file G4Tet.cc.

{
  return new G4Tet(*this);
}

◆ ComputeDimensions()

void G4Tet::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep )

overridevirtual

Dispatch method for parameterisation replication mechanism and dimension computation.

Reimplemented from G4VSolid.

Definition at line 316 of file G4Tet.cc.

319{

320}

◆ CreatePolyhedron()

G4Polyhedron * G4Tet::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 706 of file G4Tet.cc.

{
  // Check orientation of vertices
  G4ThreeVector v1 = fVertex[1] - fVertex[0];
  G4ThreeVector v2 = fVertex[2] - fVertex[0];
  G4ThreeVector v3 = fVertex[3] - fVertex[0];
  G4bool invert = v1.cross(v2).dot(v3) < 0.;
  G4int k2 = (invert) ? 3 : 2;
  G4int k3 = (invert) ? 2 : 3;
 
  // Set coordinates of vertices
  G4double xyz[4][3];
  for (G4int i = 0; i < 3; ++i)
  {
    xyz[0][i] = fVertex[0][i];
    xyz[1][i] = fVertex[1][i];
    xyz[2][i] = fVertex[k2][i];
    xyz[3][i] = fVertex[k3][i];
  }
 
  // Create polyhedron
  G4int faces[4][4] = { {1,3,2,0}, {1,4,3,0}, {1,2,4,0}, {2,3,4,0} };
  auto  ph = new G4Polyhedron;
  ph->createPolyhedron(4,4,xyz,faces);
 
  return ph;
}

Referenced by G4ArrowModel::G4ArrowModel(), and GetPolyhedron().

◆ DescribeYourselfTo()

void G4Tet::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 686 of file G4Tet.cc.

{
  scene.AddSolid (*this);
}

◆ DistanceToIn() [1/2]

G4double G4Tet::DistanceToIn ( const G4ThreeVector & p ) const

overridevirtual

Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Parameters

[in] p The point at offset p.

Returns: The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 523 of file G4Tet.cc.

{
  G4double dd[4];
  for (G4int i = 0; i < 4; ++i) { dd[i] = fNormal[i].dot(p) - fDist[i]; }
 
  G4double dist = std::max(std::max(std::max(dd[0], dd[1]), dd[2]), dd[3]);
  return (dist > 0.) ? dist : 0.;
}

◆ DistanceToIn() [2/2]

G4double G4Tet::DistanceToIn	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v ) const

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from the point at offset 'p'. If there is no intersection, returns kInfinity. The first intersection resulting from 'leaving' a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.

Returns: The distance to enter the shape.

Implements G4VSolid.

Definition at line 496 of file G4Tet.cc.

{
  G4double tin = -DBL_MAX, tout = DBL_MAX;
  for (G4int i = 0; i < 4; ++i)
  {
    G4double cosa = fNormal[i].dot(v);
    G4double dist = fNormal[i].dot(p) - fDist[i];
    if (dist >= -halfTolerance)
    {
      if (cosa >= 0.) { return kInfinity; }
      tin = std::max(tin, -dist/cosa);
    }
    else if (cosa > 0.)
    {
      tout = std::min(tout, -dist/cosa);
    }
  }
 
  return (tout - tin <= halfTolerance) ?
    kInfinity : ((tin < halfTolerance) ? 0. : tin);
}

◆ DistanceToOut() [1/2]

G4double G4Tet::DistanceToOut ( const G4ThreeVector & p ) const

overridevirtual

Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.

Parameters

[in] p The point at offset p.

Returns: The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 580 of file G4Tet.cc.

{
  G4double dd[4];
  for (G4int i = 0; i < 4; ++i) { dd[i] = fDist[i] - fNormal[i].dot(p); }
 
  G4double dist = std::min(std::min(std::min(dd[0], dd[1]), dd[2]), dd[3]);
  return (dist > 0.) ? dist : 0.;
}

◆ DistanceToOut() [2/2]

G4double G4Tet::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = false,
		G4bool *	validNorm = nullptr,
		G4ThreeVector *	n = nullptr ) const

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.
[in]	calcNorm	Flag to indicate if to calculate the normal or not.
[out]	validNorm	Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused.
[out]	n	The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.

Returns: The distance to exit the shape.

Implements G4VSolid.

Definition at line 536 of file G4Tet.cc.

{
  // Calculate distances and cosines
  G4double cosa[4], dist[4];
  G4int ind[4] = {0}, nside = 0;
  for (G4int i = 0; i < 4; ++i)
  {
    G4double tmp = fNormal[i].dot(v);
    cosa[i] = tmp;
    ind[nside] = (G4int)(tmp > 0) * i;
    nside += (G4int)(tmp > 0);
    dist[i] = fNormal[i].dot(p) - fDist[i];
  }
 
  // Find intersection (in most of cases nside == 1)
  G4double tout = DBL_MAX;
  G4int iside = 0;
  for (G4int i = 0; i < nside; ++i)
  {
    G4int k = ind[i];
    // Check: leaving the surface
    if (dist[k] >= -halfTolerance) { tout = 0.; iside = k; break; }
    // Compute distance to intersection
    G4double tmp = -dist[k]/cosa[k];
    if (tmp < tout) { tout = tmp; iside = k; }
  }
 
  // Set normal, if required, and return distance to out
  if (calcNorm)
  {
    *validNorm = true;
    *n = fNormal[iside];
  }
  return tout;
}

◆ GetCubicVolume()

G4double G4Tet::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units.

Reimplemented from G4VSolid.

Definition at line 668 of file G4Tet.cc.

{
  return fCubicVolume;
}

◆ GetEntityType()

G4GeometryType G4Tet::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4Tet" of the solid.

Implements G4VSolid.

Definition at line 593 of file G4Tet.cc.

{
  return {"G4Tet"};
}

Referenced by StreamInfo().

◆ GetExtent()

G4VisExtent G4Tet::GetExtent ( ) const

overridevirtual

Provides extent (bounding box) as possible hint to the graphics view.

Reimplemented from G4VSolid.

Definition at line 695 of file G4Tet.cc.

{
  return { fBmin.x(), fBmax.x(),
           fBmin.y(), fBmax.y(),
           fBmin.z(), fBmax.z() };
}

◆ GetPointOnSurface()

G4ThreeVector G4Tet::GetPointOnSurface ( ) const

overridevirtual

Returns a random point located and uniformly distributed on the surface of the solid.

Reimplemented from G4VSolid.

Definition at line 641 of file G4Tet.cc.

{
  constexpr G4int iface[4][3] = { {0,1,2}, {0,2,3}, {0,3,1}, {1,2,3} };
 
  // Select face
  G4double select = fSurfaceArea*G4QuickRand();
  G4int i = 0;
  i += (G4int)(select > fArea[0]);
  i += (G4int)(select > fArea[0] + fArea[1]);
  i += (G4int)(select > fArea[0] + fArea[1] + fArea[2]);
 
  // Set selected triangle
  G4ThreeVector p0 = fVertex[iface[i][0]];
  G4ThreeVector e1 = fVertex[iface[i][1]] - p0;
  G4ThreeVector e2 = fVertex[iface[i][2]] - p0;
 
  // Return random point
  G4double r1 = G4QuickRand();
  G4double r2 = G4QuickRand();
  return (r1 + r2 > 1.) ?
    p0 + e1*(1. - r1) + e2*(1. - r2) : p0 + e1*r1 + e2*r2;
}

◆ GetPolyhedron()

G4Polyhedron * G4Tet::GetPolyhedron ( ) const

overridevirtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented from G4VSolid.

Definition at line 738 of file G4Tet.cc.

{
  if (fpPolyhedron == nullptr ||
      fRebuildPolyhedron ||
      fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
      fpPolyhedron->GetNumberOfRotationSteps())
  {
    G4AutoLock l(&polyhedronMutex);
    delete fpPolyhedron;
    fpPolyhedron = CreatePolyhedron();
    fRebuildPolyhedron = false;
    l.unlock();
  }
  return fpPolyhedron;
}

◆ GetSurfaceArea()

G4double G4Tet::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 677 of file G4Tet.cc.

{
  return fSurfaceArea;
}

◆ GetVertices() [1/2]

std::vector< G4ThreeVector > G4Tet::GetVertices ( ) const

Definition at line 304 of file G4Tet.cc.

{
  std::vector<G4ThreeVector> vertices(4);
  for (G4int i = 0; i < 4; ++i) { vertices[i] = fVertex[i]; }
  return vertices;
}

Referenced by CalculateExtent().

◆ GetVertices() [2/2]

void G4Tet::GetVertices	(	G4ThreeVector &	anchor,
		G4ThreeVector &	p1,
		G4ThreeVector &	p2,
		G4ThreeVector &	p3 ) const

Definition at line 289 of file G4Tet.cc.

{
  p0 = fVertex[0];
  p1 = fVertex[1];
  p2 = fVertex[2];
  p3 = fVertex[3];
}

Referenced by G4GDMLWriteSolids::TetWrite().

◆ Inside()

EInside G4Tet::Inside ( const G4ThreeVector & p ) const

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.

Implements G4VSolid.

Definition at line 423 of file G4Tet.cc.

{
  G4double dd[4];
  for (G4int i = 0; i < 4; ++i) { dd[i] = fNormal[i].dot(p) - fDist[i]; }
 
  G4double dist = std::max(std::max(std::max(dd[0], dd[1]), dd[2]), dd[3]);
  return (dist <= -halfTolerance) ?
    kInside : ((dist <= halfTolerance) ? kSurface : kOutside);
}

◆ IsFaceted()

G4bool G4Tet::IsFaceted ( ) const

overridevirtual

Returns true as the solid has only planar faces.

Reimplemented from G4VSolid.

Definition at line 602 of file G4Tet.cc.

{
  return true;
}

◆ operator=()

G4Tet & G4Tet::operator= ( const G4Tet & rhs )

Definition at line 140 of file G4Tet.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   halfTolerance = rhs.halfTolerance;
   fCubicVolume = rhs.fCubicVolume;
   fSurfaceArea = rhs.fSurfaceArea;
   for (G4int i = 0; i < 4; ++i) { fVertex[i] = rhs.fVertex[i]; }
   for (G4int i = 0; i < 4; ++i) { fNormal[i] = rhs.fNormal[i]; }
   for (G4int i = 0; i < 4; ++i) { fDist[i] = rhs.fDist[i]; }
   for (G4int i = 0; i < 4; ++i) { fArea[i] = rhs.fArea[i]; }
   fBmin = rhs.fBmin;
   fBmax = rhs.fBmax;
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   return *this;
}

◆ SetBoundingLimits()

void G4Tet::SetBoundingLimits	(	const G4ThreeVector &	pMin,
		const G4ThreeVector &	pMax )

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Definition at line 326 of file G4Tet.cc.

{
  G4int iout[4] = { 0, 0, 0, 0 };
  for (G4int i = 0; i < 4; ++i)
  {
    iout[i] = (G4int)(fVertex[i].x() < pMin.x() ||
                      fVertex[i].y() < pMin.y() ||
                      fVertex[i].z() < pMin.z() ||
                      fVertex[i].x() > pMax.x() ||
                      fVertex[i].y() > pMax.y() ||
                      fVertex[i].z() > pMax.z());
  }
  if (iout[0] + iout[1] + iout[2] + iout[3] != 0)
  {
    std::ostringstream message;
    message << "Attempt to set bounding box that does not encapsulate solid: "
            << GetName() << " !\n"
            << "  Specified bounding box limits:\n"
            << "    pmin: " << pMin << "\n"
            << "    pmax: " << pMax << "\n"
            << "  Tetrahedron vertices:\n"
            << "    anchor " << fVertex[0] << ((iout[0]) != 0 ? " is outside\n" : "\n")
            << "    p1 "     << fVertex[1] << ((iout[1]) != 0 ? " is outside\n" : "\n")
            << "    p2 "     << fVertex[2] << ((iout[2]) != 0 ? " is outside\n" : "\n")
            << "    p3 "     << fVertex[3] << ((iout[3]) != 0 ? " is outside"   : "");
    G4Exception("G4Tet::SetBoundingLimits()", "GeomSolids0002",
                FatalException, message);
  }
  fBmin = pMin;
  fBmax = pMax;
}

◆ SetVertices()

void G4Tet::SetVertices	(	const G4ThreeVector &	anchor,
		const G4ThreeVector &	p1,
		const G4ThreeVector &	p2,
		const G4ThreeVector &	p3,
		G4bool *	degeneracyFlag = nullptr )

Modifier and accessors, for the four vertices of the shape.

Definition at line 253 of file G4Tet.cc.

{
  // Check for degeneracy
  G4bool degenerate = CheckDegeneracy(p0, p1, p2, p3);
  if (degeneracyFlag != nullptr)
  {
    *degeneracyFlag = degenerate;
  }
  else if (degenerate)
  {
    std::ostringstream message;
    message << "Degenerate tetrahedron is not permitted: " << GetName() << " !\n"
            << "  anchor: " << p0 << "\n"
            << "  p1    : " << p1 << "\n"
            << "  p2    : " << p2 << "\n"
            << "  p3    : " << p3 << "\n"
            << "  volume: "
            << std::abs((p1 - p0).cross(p2 - p0).dot(p3 - p0))/6.;
    G4Exception("G4Tet::SetVertices()", "GeomSolids0002",
                FatalException, message);
  }
 
  // Set data members
  Initialize(p0, p1, p2, p3);
 
  // Set flag to rebuild polyhedron
  fRebuildPolyhedron = true;
}

◆ StreamInfo()

std::ostream & G4Tet::StreamInfo ( std::ostream & os ) const

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 620 of file G4Tet.cc.

{
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: " << GetEntityType() << "\n"
     << " Parameters: \n"
     << "    anchor: " << fVertex[0]/mm << " mm\n"
     << "    p1    : " << fVertex[1]/mm << " mm\n"
     << "    p2    : " << fVertex[2]/mm << " mm\n"
     << "    p3    : " << fVertex[3]/mm << " mm\n"
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
  return os;
}

◆ SurfaceNormal()

G4ThreeVector G4Tet::SurfaceNormal ( const G4ThreeVector & p ) const

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.

Parameters

[in] p The point at offset p.

Returns: The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 437 of file G4Tet.cc.

{
  G4double k[4];
  for (G4int i = 0; i < 4; ++i)
  {
    k[i] = (G4double)(std::abs(fNormal[i].dot(p) - fDist[i]) <= halfTolerance);
  }
  G4double nsurf = k[0] + k[1] + k[2] + k[3];
  G4ThreeVector norm =
    k[0]*fNormal[0] + k[1]*fNormal[1] + k[2]*fNormal[2] + k[3]*fNormal[3];
 
  if (nsurf == 1.)
  {
    return norm;
  }
  if (nsurf > 1.)
  {
    return norm.unit(); // edge or vertex
  }
 
#ifdef G4SPECSDEBUG
  std::ostringstream message;
  G4long oldprc = message.precision(16);
  message << "Point p is not on surface (!?) of solid: "
          << GetName() << "\n";
  message << "Position:\n";
  message << "   p.x() = " << p.x()/mm << " mm\n";
  message << "   p.y() = " << p.y()/mm << " mm\n";
  message << "   p.z() = " << p.z()/mm << " mm";
  G4cout.precision(oldprc);
  G4Exception("G4Tet::SurfaceNormal(p)", "GeomSolids1002",
              JustWarning, message );
  DumpInfo();
#endif
  return ApproxSurfaceNormal(p);
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Tet() [1/3]

◆ ~G4Tet()

◆ G4Tet() [2/3]

◆ G4Tet() [3/3]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateExtent()

◆ CheckDegeneracy()

◆ Clone()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetEntityType()

◆ GetExtent()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetVertices() [1/2]

◆ GetVertices() [2/2]

◆ Inside()

◆ IsFaceted()

◆ operator=()

◆ SetBoundingLimits()

◆ SetVertices()

◆ StreamInfo()

◆ SurfaceNormal()