#include <G4Tet.hh>

Inheritance diagram for G4Tet:

Collaboration diagram for G4Tet:

Public Member Functions
	G4Tet (const G4String &pName, G4ThreeVector anchor, G4ThreeVector p2, G4ThreeVector p3, G4ThreeVector p4, G4bool *degeneracyFlag=0)

virtual	~G4Tet ()

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

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

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=0, G4ThreeVector n=0) const

G4double	DistanceToOut (const G4ThreeVector &p) const

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

G4GeometryType	GetEntityType () const

G4VSolid *	Clone () const

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

G4ThreeVector	GetPointOnSurface () const

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4VisExtent	GetExtent () const

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

	G4Tet (__void__ &)

	G4Tet (const G4Tet &rhs)

G4Tet &	operator= (const G4Tet &rhs)

const char *	CVSHeaderVers ()

const char *	CVSFileVers ()

void	PrintWarnings (G4bool flag)

std::vector< G4ThreeVector >	GetVertices () const

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

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () 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__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Static Public Member Functions
static G4bool	CheckDegeneracy (G4ThreeVector anchor, G4ThreeVector p2, G4ThreeVector p3, G4ThreeVector p4)

Protected Member Functions
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pTransform) const

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

Private Member Functions
G4ThreeVector	GetPointOnFace (G4ThreeVector p1, G4ThreeVector p2, G4ThreeVector p3, G4double &area) const

Static Private Attributes
static const char	CVSVers [] ="$Id: G4Tet.cc 102297 2017-01-20 13:33:54Z gcosmo $"

Additional Inherited Members
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 65 of file G4Tet.hh.

Constructor & Destructor Documentation

◆ G4Tet() [1/3]

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

Definition at line 96 of file G4Tet.cc.

   : G4VSolid(pName), fRebuildPolyhedron(false), fpPolyhedron(0), warningFlag(0)
 {
   // fV<x><y> is vector from vertex <y> to vertex <x>
   //
   G4ThreeVector fV21=p2-anchor;
   G4ThreeVector fV31=p3-anchor;
   G4ThreeVector fV41=p4-anchor;
 
   // make sure this is a correctly oriented set of points for the tetrahedron
   //
   G4double signed_vol=fV21.cross(fV31).dot(fV41);
   if(signed_vol<0.0)
   {
     G4ThreeVector temp(p4);
     p4=p3;
     p3=temp;
     temp=fV41;
     fV41=fV31;
     fV31=temp; 
   }
   fCubicVolume = std::fabs(signed_vol) / 6.;
 
   G4ThreeVector fV24=p2-p4;
   G4ThreeVector fV43=p4-p3;
   G4ThreeVector fV32=p3-p2;
 
   fXMin=std::min(std::min(std::min(anchor.x(), p2.x()),p3.x()),p4.x());
   fXMax=std::max(std::max(std::max(anchor.x(), p2.x()),p3.x()),p4.x());
   fYMin=std::min(std::min(std::min(anchor.y(), p2.y()),p3.y()),p4.y());
   fYMax=std::max(std::max(std::max(anchor.y(), p2.y()),p3.y()),p4.y());
   fZMin=std::min(std::min(std::min(anchor.z(), p2.z()),p3.z()),p4.z());
   fZMax=std::max(std::max(std::max(anchor.z(), p2.z()),p3.z()),p4.z());
 
   fDx=(fXMax-fXMin)*0.5; fDy=(fYMax-fYMin)*0.5; fDz=(fZMax-fZMin)*0.5;
 
   fMiddle=G4ThreeVector(fXMax+fXMin, fYMax+fYMin, fZMax+fZMin)*0.5;
   fMaxSize=std::max(std::max(std::max((anchor-fMiddle).mag(),
                                       (p2-fMiddle).mag()),
                              (p3-fMiddle).mag()),
                     (p4-fMiddle).mag());
 
   G4bool degenerate=std::fabs(signed_vol) < 1e-9*fMaxSize*fMaxSize*fMaxSize;
 
   if(degeneracyFlag) *degeneracyFlag=degenerate;
   else if (degenerate)
   {
     G4Exception("G4Tet::G4Tet()", "GeomSolids0002", FatalException,
                 "Degenerate tetrahedron not allowed.");
   }
 
   fTol=1e-9*(std::fabs(fXMin)+std::fabs(fXMax)+std::fabs(fYMin)
             +std::fabs(fYMax)+std::fabs(fZMin)+std::fabs(fZMax));
   //fTol=kCarTolerance;
 
   fAnchor=anchor;
   fP2=p2;
   fP3=p3;
   fP4=p4;
 
   G4ThreeVector fCenter123=(anchor+p2+p3)*(1.0/3.0); // face center
   G4ThreeVector fCenter134=(anchor+p4+p3)*(1.0/3.0);
   G4ThreeVector fCenter142=(anchor+p4+p2)*(1.0/3.0);
   G4ThreeVector fCenter234=(p2+p3+p4)*(1.0/3.0);
 
   // compute area of each triangular face by cross product
   // and sum for total surface area
 
   G4ThreeVector normal123=fV31.cross(fV21);
   G4ThreeVector normal134=fV41.cross(fV31);
   G4ThreeVector normal142=fV21.cross(fV41);
   G4ThreeVector normal234=fV32.cross(fV43);
 
   fSurfaceArea=(
       normal123.mag()+
       normal134.mag()+
       normal142.mag()+
       normal234.mag()
   )/2.0;
 
   fNormal123=normal123.unit();
   fNormal134=normal134.unit();
   fNormal142=normal142.unit();
   fNormal234=normal234.unit();
 
   fCdotN123=fCenter123.dot(fNormal123);
   fCdotN134=fCenter134.dot(fNormal134);
   fCdotN142=fCenter142.dot(fNormal142);
   fCdotN234=fCenter234.dot(fNormal234);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~G4Tet()

G4Tet::~G4Tet ( )

virtual

Definition at line 212 of file G4Tet.cc.

 {
   delete fpPolyhedron;  fpPolyhedron = 0;
 }

◆ G4Tet() [2/3]

G4Tet::G4Tet ( __void__ & a )

Definition at line 196 of file G4Tet.cc.

   : G4VSolid(a), fCubicVolume(0.), fSurfaceArea(0.),
     fRebuildPolyhedron(false), fpPolyhedron(0),
     fAnchor(0,0,0), fP2(0,0,0), fP3(0,0,0), fP4(0,0,0), fMiddle(0,0,0),
     fNormal123(0,0,0), fNormal142(0,0,0), fNormal134(0,0,0),
     fNormal234(0,0,0), warningFlag(0),
     fCdotN123(0.), fCdotN142(0.), fCdotN134(0.), fCdotN234(0.),
     fXMin(0.), fXMax(0.), fYMin(0.), fYMax(0.), fZMin(0.), fZMax(0.),
     fDx(0.), fDy(0.), fDz(0.), fTol(0.), fMaxSize(0.)
 {
 }

◆ G4Tet() [3/3]

G4Tet::G4Tet ( const G4Tet & rhs )

Definition at line 221 of file G4Tet.cc.

   : G4VSolid(rhs),
     fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
     fRebuildPolyhedron(false), fpPolyhedron(0), fAnchor(rhs.fAnchor),
     fP2(rhs.fP2), fP3(rhs.fP3), fP4(rhs.fP4), fMiddle(rhs.fMiddle),
     fNormal123(rhs.fNormal123), fNormal142(rhs.fNormal142),
     fNormal134(rhs.fNormal134), fNormal234(rhs.fNormal234),
     warningFlag(rhs.warningFlag), fCdotN123(rhs.fCdotN123),
     fCdotN142(rhs.fCdotN142), fCdotN134(rhs.fCdotN134),
     fCdotN234(rhs.fCdotN234), fXMin(rhs.fXMin), fXMax(rhs.fXMax),
     fYMin(rhs.fYMin), fYMax(rhs.fYMax), fZMin(rhs.fZMin), fZMax(rhs.fZMax),
     fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz), fTol(rhs.fTol),
     fMaxSize(rhs.fMaxSize)
 {
 }

Member Function Documentation

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 301 of file G4Tet.cc.

 {
   G4double xMin,xMax;
   G4double yMin,yMax;
   G4double zMin,zMax;
 
   if (pTransform.IsRotated())
   {
     G4ThreeVector pp0=pTransform.TransformPoint(fAnchor);
     G4ThreeVector pp1=pTransform.TransformPoint(fP2);
     G4ThreeVector pp2=pTransform.TransformPoint(fP3);
     G4ThreeVector pp3=pTransform.TransformPoint(fP4);
 
     xMin    = std::min(std::min(std::min(pp0.x(), pp1.x()),pp2.x()),pp3.x());
     xMax    = std::max(std::max(std::max(pp0.x(), pp1.x()),pp2.x()),pp3.x());
     yMin    = std::min(std::min(std::min(pp0.y(), pp1.y()),pp2.y()),pp3.y());
     yMax    = std::max(std::max(std::max(pp0.y(), pp1.y()),pp2.y()),pp3.y());
     zMin    = std::min(std::min(std::min(pp0.z(), pp1.z()),pp2.z()),pp3.z());
     zMax    = std::max(std::max(std::max(pp0.z(), pp1.z()),pp2.z()),pp3.z());
 
   }
   else
   {
     G4double xoffset = pTransform.NetTranslation().x() ;
     xMin    = xoffset + fXMin;
     xMax    = xoffset + fXMax;
     G4double yoffset = pTransform.NetTranslation().y() ;
     yMin    = yoffset + fYMin;
     yMax    = yoffset + fYMax;
     G4double zoffset = pTransform.NetTranslation().z() ;
     zMin    = zoffset + fZMin;
     zMax    = zoffset + fZMax;
   }
 
   if (pVoxelLimit.IsXLimited())
   {
     if ( (xMin > pVoxelLimit.GetMaxXExtent()+fTol) || 
          (xMax < pVoxelLimit.GetMinXExtent()-fTol)  )  { return false; }
     else
     {
       xMin = std::max(xMin, pVoxelLimit.GetMinXExtent());
       xMax = std::min(xMax, pVoxelLimit.GetMaxXExtent());
     }
   }
 
   if (pVoxelLimit.IsYLimited())
   {
     if ( (yMin > pVoxelLimit.GetMaxYExtent()+fTol) ||
          (yMax < pVoxelLimit.GetMinYExtent()-fTol)  )  { return false; }
     else
     {
       yMin = std::max(yMin, pVoxelLimit.GetMinYExtent());
       yMax = std::min(yMax, pVoxelLimit.GetMaxYExtent());
     }
     }
 
     if (pVoxelLimit.IsZLimited())
     {
       if ( (zMin > pVoxelLimit.GetMaxZExtent()+fTol) ||
            (zMax < pVoxelLimit.GetMinZExtent()-fTol)  )  { return false; }
     else
     {
       zMin = std::max(zMin, pVoxelLimit.GetMinZExtent());
       zMax = std::min(zMax, pVoxelLimit.GetMaxZExtent());
     }
   }
 
   switch (pAxis)
   {
     case kXAxis:
       pMin=xMin;
       pMax=xMax;
       break;
     case kYAxis:
       pMin=yMin;
       pMax=yMax;
       break;
     case kZAxis:
       pMin=zMin;
       pMax=zMax;
       break;
     default:
       break;
   }
 
   return true;
 } 

Here is the call graph for this function:

◆ CheckDegeneracy()

G4bool G4Tet::CheckDegeneracy	(	G4ThreeVector	anchor,
		G4ThreeVector	p2,
		G4ThreeVector	p3,
		G4ThreeVector	p4
	)

static

Definition at line 275 of file G4Tet.cc.

 {
   G4bool result;
   G4Tet *object=new G4Tet("temp",anchor,p2,p3,p4,&result);
   delete object;
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clone()

G4VSolid * G4Tet::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 710 of file G4Tet.cc.

 {
   return new G4Tet(*this);
 }

Here is the call graph for this function:

◆ ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 291 of file G4Tet.cc.

294 {

295 }

◆ CreatePolyhedron()

G4Polyhedron * G4Tet::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 843 of file G4Tet.cc.

 {
   G4Polyhedron *ph=new G4Polyhedron;
   G4double xyz[4][3];
   const G4int faces[4][4]={{1,3,2,0},{1,4,3,0},{1,2,4,0},{2,3,4,0}};
   xyz[0][0]=fAnchor.x(); xyz[0][1]=fAnchor.y(); xyz[0][2]=fAnchor.z();
   xyz[1][0]=fP2.x(); xyz[1][1]=fP2.y(); xyz[1][2]=fP2.z();
   xyz[2][0]=fP3.x(); xyz[2][1]=fP3.y(); xyz[2][2]=fP3.z();
   xyz[3][0]=fP4.x(); xyz[3][1]=fP4.y(); xyz[3][2]=fP4.z();
 
   ph->createPolyhedron(4,4,xyz,faces);
 
   return ph;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateRotatedVertices()

G4ThreeVectorList * G4Tet::CreateRotatedVertices ( const G4AffineTransform & pTransform ) const

protected

Definition at line 670 of file G4Tet.cc.

 {
   G4ThreeVectorList* vertices = new G4ThreeVectorList();
 
   if (vertices)
   {
     vertices->reserve(4);
     G4ThreeVector vertex0(fAnchor);
     G4ThreeVector vertex1(fP2);
     G4ThreeVector vertex2(fP3);
     G4ThreeVector vertex3(fP4);
 
     vertices->push_back(pTransform.TransformPoint(vertex0));
     vertices->push_back(pTransform.TransformPoint(vertex1));
     vertices->push_back(pTransform.TransformPoint(vertex2));
     vertices->push_back(pTransform.TransformPoint(vertex3));
   }
   else
   {
     DumpInfo();
     G4Exception("G4Tet::CreateRotatedVertices()",
                 "GeomSolids0003", FatalException,
                 "Error in allocation of vertices. Out of memory !");
   }
   return vertices;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CVSFileVers()

const char* G4Tet::CVSFileVers ( )

inline

Definition at line 134 of file G4Tet.hh.

135 { return CVSVers; }

G4Tet::CVSVers

static const char CVSVers[]

Definition: G4Tet.hh:161

◆ CVSHeaderVers()

const char* G4Tet::CVSHeaderVers ( )

inline

Definition at line 132 of file G4Tet.hh.

133 { return "$Id: G4Tet.hh 83572 2014-09-01 15:23:27Z gcosmo $"; }

◆ DescribeYourselfTo()

void G4Tet::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 825 of file G4Tet.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 487 of file G4Tet.cc.

 {
     G4ThreeVector vu(v.unit()), hp;
     G4double vdotn, t, tmin=kInfinity;
 
     G4double extraDistance=10.0*fTol; // a little ways into the solid
 
     vdotn=-vu.dot(fNormal123);
     if(vdotn > 1e-12)
     { // this is a candidate face, since it is pointing at us
       t=(p.dot(fNormal123)-fCdotN123)/vdotn; // #  distance to intersection
       if( (t>=-fTol) && (t<tmin) )
       { // if not true, we're going away from this face or it's not close
         hp=p+vu*(t+extraDistance); // a little beyond point of intersection
         if ( ( hp.dot(fNormal134)-fCdotN134 < 0.0 ) &&
              ( hp.dot(fNormal142)-fCdotN142 < 0.0 ) &&
              ( hp.dot(fNormal234)-fCdotN234 < 0.0 ) )
         {
           tmin=t;
         }
       }
     }
 
     vdotn=-vu.dot(fNormal134);
     if(vdotn > 1e-12)
     { // # this is a candidate face, since it is pointing at us
       t=(p.dot(fNormal134)-fCdotN134)/vdotn; // #  distance to intersection
       if( (t>=-fTol) && (t<tmin) )
       { // if not true, we're going away from this face
         hp=p+vu*(t+extraDistance); // a little beyond point of intersection
         if ( ( hp.dot(fNormal123)-fCdotN123 < 0.0 ) && 
              ( hp.dot(fNormal142)-fCdotN142 < 0.0 ) &&
              ( hp.dot(fNormal234)-fCdotN234 < 0.0 ) )
         {
           tmin=t;
         }
       }
     }
 
     vdotn=-vu.dot(fNormal142);
     if(vdotn > 1e-12)
     { // # this is a candidate face, since it is pointing at us
       t=(p.dot(fNormal142)-fCdotN142)/vdotn; // #  distance to intersection
       if( (t>=-fTol) && (t<tmin) )
       { // if not true, we're going away from this face
         hp=p+vu*(t+extraDistance); // a little beyond point of intersection
         if ( ( hp.dot(fNormal123)-fCdotN123 < 0.0 ) &&
              ( hp.dot(fNormal134)-fCdotN134 < 0.0 ) &&
              ( hp.dot(fNormal234)-fCdotN234 < 0.0 ) )
         {
           tmin=t;
         }
       }
     }
 
     vdotn=-vu.dot(fNormal234);
     if(vdotn > 1e-12)
     { // # this is a candidate face, since it is pointing at us
       t=(p.dot(fNormal234)-fCdotN234)/vdotn; // #  distance to intersection
       if( (t>=-fTol) && (t<tmin) )
       { // if not true, we're going away from this face
         hp=p+vu*(t+extraDistance); // a little beyond point of intersection
         if ( ( hp.dot(fNormal123)-fCdotN123 < 0.0 ) &&
              ( hp.dot(fNormal134)-fCdotN134 < 0.0 ) &&
              ( hp.dot(fNormal142)-fCdotN142 < 0.0 ) )
         {
           tmin=t;
         }
       }
     }
 
   return std::max(0.0,tmin);
 }

Here is the call graph for this function:

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 568 of file G4Tet.cc.

 {
   G4double dd=(p-fMiddle).mag() - fMaxSize - fTol;
   return std::max(0.0, dd);
 }

◆ DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 580 of file G4Tet.cc.

 {
     G4ThreeVector vu(v.unit());
     G4double t1=kInfinity,t2=kInfinity,t3=kInfinity,t4=kInfinity, vdotn, tt;
 
     vdotn=vu.dot(fNormal123);
     if(vdotn > 1e-12)  // #we're heading towards this face, so it is a candidate
     {
       t1=(fCdotN123-p.dot(fNormal123))/vdotn; // #  distance to intersection
     }
 
     vdotn=vu.dot(fNormal134);
     if(vdotn > 1e-12) // #we're heading towards this face, so it is a candidate
     {
       t2=(fCdotN134-p.dot(fNormal134))/vdotn; // #  distance to intersection
     }
 
     vdotn=vu.dot(fNormal142);
     if(vdotn > 1e-12) // #we're heading towards this face, so it is a candidate
     {
       t3=(fCdotN142-p.dot(fNormal142))/vdotn; // #  distance to intersection
     }
 
     vdotn=vu.dot(fNormal234);
     if(vdotn > 1e-12) // #we're heading towards this face, so it is a candidate
     {
       t4=(fCdotN234-p.dot(fNormal234))/vdotn; // #  distance to intersection
     }
 
     tt=std::min(std::min(std::min(t1,t2),t3),t4);
 
     if (warningFlag && (tt == kInfinity || tt < -fTol))
     {
       DumpInfo();
       std::ostringstream message;
       message << "No good intersection found or already outside!?" << G4endl
               << "p = " << p / mm << "mm" << G4endl
               << "v = " << v  << G4endl
               << "t1, t2, t3, t4 (mm) "
               << t1/mm << ", " << t2/mm << ", " << t3/mm << ", " << t4/mm;
       G4Exception("G4Tet::DistanceToOut(p,v,...)", "GeomSolids1002",
                   JustWarning, message);
       if(validNorm)
       {
         *validNorm=false; // flag normal as meaningless
       }
     }
     else if(calcNorm && n)
     {
       G4ThreeVector normal;
       if(tt==t1)        { normal=fNormal123; }
       else if (tt==t2)  { normal=fNormal134; }
       else if (tt==t3)  { normal=fNormal142; }
       else if (tt==t4)  { normal=fNormal234; }
       *n=normal;
       if(validNorm) { *validNorm=true; }
     }
 
     return std::max(tt,0.0); // avoid tt<0.0 by a tiny bit
                              // if we are right on a face
 }

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 649 of file G4Tet.cc.

 {
   G4double t1,t2,t3,t4;
   t1=fCdotN123-p.dot(fNormal123); //  distance to plane, positive if inside
   t2=fCdotN134-p.dot(fNormal134); //  distance to plane
   t3=fCdotN142-p.dot(fNormal142); //  distance to plane
   t4=fCdotN234-p.dot(fNormal234); //  distance to plane
 
   // if any one of these is negative, we are outside,
   // so return zero in that case
 
   G4double tmin=std::min(std::min(std::min(t1,t2),t3),t4);
   return (tmin < fTol)? 0:tmin;
 }

Here is the call graph for this function:

◆ GetCubicVolume()

G4double G4Tet::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 805 of file G4Tet.cc.

 {
   return fCubicVolume;
 }

◆ GetEntityType()

G4GeometryType G4Tet::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 701 of file G4Tet.cc.

 {
   return G4String("G4Tet");
 }

◆ GetExtent()

G4VisExtent G4Tet::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 834 of file G4Tet.cc.

 {
   return G4VisExtent (fXMin, fXMax, fYMin, fYMax, fZMin, fZMax);
 }

◆ GetPointOnFace()

G4ThreeVector G4Tet::GetPointOnFace	(	G4ThreeVector	p1,
		G4ThreeVector	p2,
		G4ThreeVector	p3,
		G4double &	area
	)		const

private

Definition at line 748 of file G4Tet.cc.

 {
   G4double lambda1,lambda2;
   G4ThreeVector v, w;
 
   v = p3 - p1;
   w = p1 - p2;
 
   lambda1 = G4RandFlat::shoot(0.,1.);
   lambda2 = G4RandFlat::shoot(0.,lambda1);
 
   area = 0.5*(v.cross(w)).mag();
 
   return (p2 + lambda1*w + lambda2*v);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPointOnSurface()

G4ThreeVector G4Tet::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 769 of file G4Tet.cc.

 {
   G4double chose,aOne,aTwo,aThree,aFour;
   G4ThreeVector p1, p2, p3, p4;
   
   p1 = GetPointOnFace(fAnchor,fP2,fP3,aOne);
   p2 = GetPointOnFace(fAnchor,fP4,fP3,aTwo);
   p3 = GetPointOnFace(fAnchor,fP4,fP2,aThree);
   p4 = GetPointOnFace(fP4,fP3,fP2,aFour);
   
   chose = G4RandFlat::shoot(0.,aOne+aTwo+aThree+aFour);
   if( (chose>=0.) && (chose <aOne) ) {return p1;}
   else if( (chose>=aOne) && (chose < aOne+aTwo) ) {return p2;}
   else if( (chose>=aOne+aTwo) && (chose<aOne+aTwo+aThree) ) {return p3;}
   return p4;
 }

Here is the call graph for this function:

◆ GetPolyhedron()

G4Polyhedron * G4Tet::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 862 of file G4Tet.cc.

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

Here is the call graph for this function:

◆ GetSurfaceArea()

G4double G4Tet::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 814 of file G4Tet.cc.

 {
   return fSurfaceArea;
 }

◆ GetVertices()

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

Definition at line 790 of file G4Tet.cc.

 {
   std::vector<G4ThreeVector> vertices(4);
   vertices[0] = fAnchor;
   vertices[1] = fP2;
   vertices[2] = fP3;
   vertices[3] = fP4;
 
   return vertices;
 }

Here is the caller graph for this function:

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 396 of file G4Tet.cc.

 {
   G4double r123, r134, r142, r234;
 
   // this is written to allow if-statement truncation so the outside test
   // (where most of the world is) can fail very quickly and efficiently
 
   if ( (r123=p.dot(fNormal123)-fCdotN123) > fTol ||
        (r134=p.dot(fNormal134)-fCdotN134) > fTol ||
        (r142=p.dot(fNormal142)-fCdotN142) > fTol ||
        (r234=p.dot(fNormal234)-fCdotN234) > fTol )
   {
     return kOutside; // at least one is out!
   }
   else if( (r123 < -fTol)&&(r134 < -fTol)&&(r142 < -fTol)&&(r234 < -fTol) )
   {
     return kInside; // all are definitively inside
   }
   else
   {
     return kSurface; // too close to tell
   }
 }

Here is the call graph for this function:

◆ operator=()

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

Definition at line 242 of file G4Tet.cc.

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4VSolid::operator=(rhs);
 
    // Copy data
    //
    fCubicVolume = rhs.fCubicVolume; fSurfaceArea = rhs.fSurfaceArea;
    fAnchor = rhs.fAnchor;
    fP2 = rhs.fP2; fP3 = rhs.fP3; fP4 = rhs.fP4; fMiddle = rhs.fMiddle;
    fNormal123 = rhs.fNormal123; fNormal142 = rhs.fNormal142;
    fNormal134 = rhs.fNormal134; fNormal234 = rhs.fNormal234;
    warningFlag = rhs.warningFlag; fCdotN123 = rhs.fCdotN123;
    fCdotN142 = rhs.fCdotN142; fCdotN134 = rhs.fCdotN134;
    fCdotN234 = rhs.fCdotN234; fXMin = rhs.fXMin; fXMax = rhs.fXMax;
    fYMin = rhs.fYMin; fYMax = rhs.fYMax; fZMin = rhs.fZMin; fZMax = rhs.fZMax;
    fDx = rhs.fDx; fDy = rhs.fDy; fDz = rhs.fDz; fTol = rhs.fTol;
    fMaxSize = rhs.fMaxSize;
    fRebuildPolyhedron = false;
    delete fpPolyhedron; fpPolyhedron = 0;
 
    return *this;
 }

Here is the call graph for this function:

◆ PrintWarnings()

void G4Tet::PrintWarnings ( G4bool flag )

inline

Definition at line 136 of file G4Tet.hh.

137 { warningFlag=flag; }

G4Tet::warningFlag

G4bool warningFlag

Definition: G4Tet.hh:168

Here is the call graph for this function:

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 719 of file G4Tet.cc.

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
   << "    *** Dump for solid - " << GetName() << " ***\n"
   << "    ===================================================\n"
   << " Solid type: G4Tet\n"
   << " Parameters: \n"
   << "    anchor: " << fAnchor/mm << " mm \n"
   << "    p2: " << fP2/mm << " mm \n"
   << "    p3: " << fP3/mm << " mm \n"
   << "    p4: " << fP4/mm << " mm \n"
   << "    normal123: " << fNormal123 << " \n"
   << "    normal134: " << fNormal134 << " \n"
   << "    normal142: " << fNormal142 << " \n"
   << "    normal234: " << fNormal234 << " \n"
   << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 427 of file G4Tet.cc.

 {
   G4double r123=std::fabs(p.dot(fNormal123)-fCdotN123);
   G4double r134=std::fabs(p.dot(fNormal134)-fCdotN134);
   G4double r142=std::fabs(p.dot(fNormal142)-fCdotN142);
   G4double r234=std::fabs(p.dot(fNormal234)-fCdotN234);
 
   const G4double delta = 0.5*kCarTolerance;
   G4ThreeVector sumnorm(0., 0., 0.);
   G4int noSurfaces=0; 
 
   if (r123 <= delta)         
   {
      noSurfaces ++; 
      sumnorm= fNormal123; 
   }
 
   if (r134 <= delta)    
   {
      noSurfaces ++; 
      sumnorm += fNormal134; 
   }
  
   if (r142 <= delta)    
   {
      noSurfaces ++; 
      sumnorm += fNormal142;
   }
   if (r234 <= delta)    
   {
      noSurfaces ++; 
      sumnorm += fNormal234;
   }
   
   if( noSurfaces > 0 )
   { 
      if( noSurfaces == 1 )
      { 
        return sumnorm; 
      }
      else
      {
        return sumnorm.unit();
      }
   }
   else // Approximative Surface Normal
   {
 
     if( (r123<=r134) && (r123<=r142) && (r123<=r234) ) { return fNormal123; }
     else if ( (r134<=r142) && (r134<=r234) )           { return fNormal134; }
     else if (r142 <= r234)                             { return fNormal142; }
     return fNormal234;
   }
 }

Here is the call graph for this function:

Member Data Documentation

◆ CVSVers

const char G4Tet::CVSVers ="$Id: G4Tet.cc 102297 2017-01-20 13:33:54Z gcosmo $"

staticprivate

Definition at line 161 of file G4Tet.hh.

◆ fAnchor

G4ThreeVector G4Tet::fAnchor

private

Definition at line 165 of file G4Tet.hh.

◆ fCdotN123

G4double G4Tet::fCdotN123

private

Definition at line 170 of file G4Tet.hh.

◆ fCdotN134

G4double G4Tet::fCdotN134

private

Definition at line 170 of file G4Tet.hh.

◆ fCdotN142

G4double G4Tet::fCdotN142

private

Definition at line 170 of file G4Tet.hh.

◆ fCdotN234

G4double G4Tet::fCdotN234

private

Definition at line 170 of file G4Tet.hh.

◆ fCubicVolume

G4double G4Tet::fCubicVolume

private

Definition at line 154 of file G4Tet.hh.

◆ fDx

G4double G4Tet::fDx

private

Definition at line 172 of file G4Tet.hh.

◆ fDy

G4double G4Tet::fDy

private

Definition at line 172 of file G4Tet.hh.

◆ fDz

G4double G4Tet::fDz

private

Definition at line 172 of file G4Tet.hh.

◆ fMaxSize

G4double G4Tet::fMaxSize

private

Definition at line 172 of file G4Tet.hh.

◆ fMiddle

G4ThreeVector G4Tet::fMiddle

private

Definition at line 165 of file G4Tet.hh.

◆ fNormal123

G4ThreeVector G4Tet::fNormal123

private

Definition at line 166 of file G4Tet.hh.

◆ fNormal134

G4ThreeVector G4Tet::fNormal134

private

Definition at line 166 of file G4Tet.hh.

◆ fNormal142

G4ThreeVector G4Tet::fNormal142

private

Definition at line 166 of file G4Tet.hh.

◆ fNormal234

G4ThreeVector G4Tet::fNormal234

private

Definition at line 166 of file G4Tet.hh.

◆ fP2

G4ThreeVector G4Tet::fP2

private

Definition at line 165 of file G4Tet.hh.

◆ fP3

G4ThreeVector G4Tet::fP3

private

Definition at line 165 of file G4Tet.hh.

◆ fP4

G4ThreeVector G4Tet::fP4

private

Definition at line 165 of file G4Tet.hh.

◆ fpPolyhedron

G4Polyhedron* G4Tet::fpPolyhedron

mutableprivate

Definition at line 157 of file G4Tet.hh.

◆ fRebuildPolyhedron

G4bool G4Tet::fRebuildPolyhedron

mutableprivate

Definition at line 156 of file G4Tet.hh.

◆ fSurfaceArea

G4double G4Tet::fSurfaceArea

private

Definition at line 154 of file G4Tet.hh.

◆ fTol

G4double G4Tet::fTol

private

Definition at line 172 of file G4Tet.hh.

◆ fXMax

G4double G4Tet::fXMax

private

Definition at line 171 of file G4Tet.hh.

◆ fXMin

G4double G4Tet::fXMin

private

Definition at line 171 of file G4Tet.hh.

◆ fYMax

G4double G4Tet::fYMax

private

Definition at line 171 of file G4Tet.hh.

◆ fYMin

G4double G4Tet::fYMin

private

Definition at line 171 of file G4Tet.hh.

◆ fZMax

G4double G4Tet::fZMax

private

Definition at line 171 of file G4Tet.hh.

◆ fZMin

G4double G4Tet::fZMin

private

Definition at line 171 of file G4Tet.hh.

◆ warningFlag

G4bool G4Tet::warningFlag

private

Definition at line 168 of file G4Tet.hh.

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

Private Attributes
G4double	fCubicVolume

G4double	fSurfaceArea

G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

G4ThreeVector	fAnchor

G4ThreeVector	fP2

G4ThreeVector	fP3

G4ThreeVector	fP4

G4ThreeVector	fMiddle

G4ThreeVector	fNormal123

G4ThreeVector	fNormal142

G4ThreeVector	fNormal134

G4ThreeVector	fNormal234

G4bool	warningFlag

G4double	fCdotN123

G4double	fCdotN142

G4double	fCdotN134

G4double	fCdotN234

G4double	fXMin

G4double	fXMax

G4double	fYMin

G4double	fYMax

G4double	fZMin

G4double	fZMax

G4double	fDx

G4double	fDy

G4double	fDz

G4double	fTol

G4double	fMaxSize

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Tet() [1/3]

◆ ~G4Tet()

◆ G4Tet() [2/3]

◆ G4Tet() [3/3]

Member Function Documentation

◆ CalculateExtent()

◆ CheckDegeneracy()

◆ Clone()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ CVSFileVers()

◆ CVSHeaderVers()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetEntityType()

◆ GetExtent()

◆ GetPointOnFace()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetVertices()

◆ Inside()

◆ operator=()

◆ PrintWarnings()

◆ StreamInfo()

◆ SurfaceNormal()

Member Data Documentation

◆ CVSVers

◆ fAnchor

◆ fCdotN123

◆ fCdotN134

◆ fCdotN142

◆ fCdotN234

◆ fCubicVolume

◆ fDx

◆ fDy

◆ fDz

◆ fMaxSize

◆ fMiddle

◆ fNormal123

◆ fNormal134

◆ fNormal142

◆ fNormal234

◆ fP2

◆ fP3

◆ fP4

◆ fpPolyhedron

◆ fRebuildPolyhedron

◆ fSurfaceArea

◆ fTol

◆ fXMax

◆ fXMin

◆ fYMax

◆ fYMin

◆ fZMax

◆ fZMin

◆ warningFlag