#include <G4Tet.hh>

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

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

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Additional Inherited Members
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 65 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 89 of file G4Tet.cc.

References CLHEP::Hep3Vector::cross(), CLHEP::Hep3Vector::dot(), FatalException, G4Exception(), CLHEP::Hep3Vector::mag(), G4INCL::Math::max(), G4INCL::Math::min(), and CLHEP::Hep3Vector::unit().

Referenced by CheckDegeneracy(), and Clone().

   : G4VSolid(pName), 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);
 }

G4Tet::~G4Tet ( )

virtual

Definition at line 204 of file G4Tet.cc.

 {
   delete fpPolyhedron;
 }

G4Tet::G4Tet ( __void__ & a )

Definition at line 189 of file G4Tet.cc.

   : G4VSolid(a), fCubicVolume(0.), fSurfaceArea(0.), 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 213 of file G4Tet.cc.

   : G4VSolid(rhs),
     fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
     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 291 of file G4Tet.cc.

References G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), G4AffineTransform::IsRotated(), G4VoxelLimits::IsXLimited(), G4VoxelLimits::IsYLimited(), G4VoxelLimits::IsZLimited(), kXAxis, kYAxis, kZAxis, G4INCL::Math::max(), G4INCL::Math::min(), G4AffineTransform::NetTranslation(), G4AffineTransform::TransformPoint(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   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;
 } 

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

static

Definition at line 265 of file G4Tet.cc.

References G4Tet().

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

G4VSolid * G4Tet::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 700 of file G4Tet.cc.

References G4Tet().

 {
   return new G4Tet(*this);
 }

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

virtual

Reimplemented from G4VSolid.

Definition at line 281 of file G4Tet.cc.

284 {

285 }

G4Polyhedron * G4Tet::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 833 of file G4Tet.cc.

References HepPolyhedron::createPolyhedron(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by GetPolyhedron().

 {
   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;
 }

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

protected

Definition at line 660 of file G4Tet.cc.

References G4VSolid::DumpInfo(), FatalException, G4Exception(), and G4AffineTransform::TransformPoint().

 {
   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;
 }

const char* G4Tet::CVSFileVers ( )

inline

Definition at line 134 of file G4Tet.hh.

135 { return CVSVers; }

const char* G4Tet::CVSHeaderVers ( )

inline

Definition at line 132 of file G4Tet.hh.

133 { return "$Id: G4Tet.hh 76263 2013-11-08 11:41:52Z gcosmo $"; }

void G4Tet::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 815 of file G4Tet.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

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

virtual

Implements G4VSolid.

Definition at line 477 of file G4Tet.cc.

References CLHEP::Hep3Vector::dot(), G4INCL::Math::max(), and CLHEP::Hep3Vector::unit().

 {
     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);
 }

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

virtual

Implements G4VSolid.

Definition at line 558 of file G4Tet.cc.

References G4INCL::Math::max().

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

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 570 of file G4Tet.cc.

References CLHEP::Hep3Vector::dot(), G4VSolid::DumpInfo(), G4endl, G4Exception(), JustWarning, G4INCL::Math::max(), G4INCL::Math::min(), python.hepunit::mm, plottest35::t1, and CLHEP::Hep3Vector::unit().

 {
     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
 }

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

virtual

Implements G4VSolid.

Definition at line 639 of file G4Tet.cc.

References CLHEP::Hep3Vector::dot(), G4INCL::Math::min(), and plottest35::t1.

 {
   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;
 }

G4double G4Tet::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 795 of file G4Tet.cc.

 {
   return fCubicVolume;
 }

G4GeometryType G4Tet::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 691 of file G4Tet.cc.

 {
   return G4String("G4Tet");
 }

G4VisExtent G4Tet::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 824 of file G4Tet.cc.

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

G4ThreeVector G4Tet::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 759 of file G4Tet.cc.

References G4INCL::DeJongSpin::shoot().

 {
   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 = RandFlat::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;
 }

G4Polyhedron * G4Tet::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 852 of file G4Tet.cc.

References CreatePolyhedron(), HepPolyhedron::GetNumberOfRotationSteps(), and G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation().

 {
   if (!fpPolyhedron ||
       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
       fpPolyhedron->GetNumberOfRotationSteps())
     {
       delete fpPolyhedron;
       fpPolyhedron = CreatePolyhedron();
     }
   return fpPolyhedron;
 }

G4double G4Tet::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 804 of file G4Tet.cc.

 {
   return fSurfaceArea;
 }

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

Definition at line 780 of file G4Tet.cc.

Referenced by G4GDMLWriteSolids::TetWrite().

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

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

virtual

Implements G4VSolid.

Definition at line 386 of file G4Tet.cc.

References CLHEP::Hep3Vector::dot(), kInside, kOutside, and kSurface.

 {
   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
   }
 }

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

Definition at line 234 of file G4Tet.cc.

References G4VSolid::operator=().

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4VSolid::operator=(rhs);
 
    // Copy data
    //
    fCubicVolume = rhs.fCubicVolume; fSurfaceArea = rhs.fSurfaceArea;
    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;
 
    return *this;
 }

void G4Tet::PrintWarnings ( G4bool flag )

inline

Definition at line 136 of file G4Tet.hh.

137 { warningFlag=flag; }

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

virtual

Implements G4VSolid.

Definition at line 709 of file G4Tet.cc.

References G4VSolid::GetName(), and python.hepunit::mm.

 {
   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;
 }

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

virtual

Implements G4VSolid.

Definition at line 417 of file G4Tet.cc.

References CLHEP::Hep3Vector::dot(), G4VSolid::kCarTolerance, and CLHEP::Hep3Vector::unit().

 {
   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;
   }
 }

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation