#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)

void	Extent (G4ThreeVector &pMin, G4ThreeVector &pMax) const

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)

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

Definition at line 66 of file G4Tet.hh.

Constructor & Destructor Documentation

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

Definition at line 99 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 ( )

virtual

Definition at line 215 of file G4Tet.cc.

 {
   delete fpPolyhedron;  fpPolyhedron = 0;
 }

G4Tet::G4Tet ( __void__ & a )

Definition at line 199 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::G4Tet ( const G4Tet & rhs )

Definition at line 224 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

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

virtual

Implements G4VSolid.

Definition at line 327 of file G4Tet.cc.

 {
   G4ThreeVector bmin, bmax;
   G4bool exist;
 
   // Check bounding box (bbox)
   //
   Extent(bmin,bmax);
   G4BoundingEnvelope bbox(bmin,bmax);
 #ifdef G4BBOX_EXTENT
   if (true) return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
 #endif
   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);
   exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
   return exist;
 }

Here is the call graph for this function:

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

static

Definition at line 278 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:

G4VSolid * G4Tet::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 653 of file G4Tet.cc.

 {
   return new G4Tet(*this);
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4VSolid.

Definition at line 294 of file G4Tet.cc.

297 {

298 }

G4Polyhedron * G4Tet::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 786 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:

const char* G4Tet::CVSFileVers ( )

inline

Definition at line 137 of file G4Tet.hh.

138 { return CVSVers; }

const char* G4Tet::CVSHeaderVers ( )

inline

Definition at line 135 of file G4Tet.hh.

136 { return "$Id: G4Tet.hh 99781 2016-10-05 10:18:54Z gcosmo $"; }

void G4Tet::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 768 of file G4Tet.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 463 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:

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

virtual

Implements G4VSolid.

Definition at line 544 of file G4Tet.cc.

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

Here is the call graph for this function:

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 556 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:

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

virtual

Implements G4VSolid.

Definition at line 625 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:

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

virtual

Reimplemented from G4VSolid.

Definition at line 304 of file G4Tet.cc.

 {
   pMin.set(fXMin,fYMin,fZMin);
   pMax.set(fXMax,fYMax,fZMax);
 
   // Check correctness of the bounding box
   //
   if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
   {
     std::ostringstream message;
     message << "Bad bounding box (min >= max) for solid: "
             << GetName() << " !"
             << "\npMin = " << pMin
             << "\npMax = " << pMax;
     G4Exception("G4Tet::Extent()", "GeomMgt0001", JustWarning, message);
     DumpInfo();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4Tet::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 748 of file G4Tet.cc.

 {
   return fCubicVolume;
 }

G4GeometryType G4Tet::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 644 of file G4Tet.cc.

 {
   return G4String("G4Tet");
 }

G4VisExtent G4Tet::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 777 of file G4Tet.cc.

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

G4ThreeVector G4Tet::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 712 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:

G4Polyhedron * G4Tet::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 805 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:

G4double G4Tet::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 757 of file G4Tet.cc.

 {
   return fSurfaceArea;
 }

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

Definition at line 733 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:

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

virtual

Implements G4VSolid.

Definition at line 372 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:

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

Definition at line 245 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:

void G4Tet::PrintWarnings ( G4bool flag )

inline

Definition at line 139 of file G4Tet.hh.

140 { warningFlag=flag; }

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

virtual

Implements G4VSolid.

Definition at line 662 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:

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

virtual

Implements G4VSolid.

Definition at line 403 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:

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

geant4.10.03.p01/source/geometry/solids/specific/include/G4Tet.hh
geant4.10.03.p01/source/geometry/solids/specific/src/G4Tet.cc

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation