#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

G4NURBS *	CreateNURBS () 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

virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const =0

virtual EInside	Inside (const G4ThreeVector &p) const =0

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const =0

virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const =0

virtual G4double	DistanceToIn (const G4ThreeVector &p) const =0

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

virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0

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

virtual G4double	GetCubicVolume ()

virtual G4double	GetSurfaceArea ()

virtual G4GeometryType	GetEntityType () const =0

virtual G4ThreeVector	GetPointOnSurface () const

virtual G4VSolid *	Clone () const

virtual std::ostream &	StreamInfo (std::ostream &os) const =0

void	DumpInfo () const

virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0

virtual G4VisExtent	GetExtent () const

virtual G4Polyhedron *	CreatePolyhedron () const

virtual G4NURBS *	CreateNURBS () const

virtual G4Polyhedron *	GetPolyhedron () 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 56 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 89 of file G4Tet.cc.

  : 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::~G4Tet ( )

virtual

Definition at line 204 of file G4Tet.cc.

{
  delete fpPolyhedron;
}

◆ G4Tet() [2/3]

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() [3/3]

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

◆ CalculateExtent()

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.

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

◆ CheckDegeneracy()

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

static

Definition at line 265 of file G4Tet.cc.

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

◆ Clone()

G4VSolid * G4Tet::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 659 of file G4Tet.cc.

{
  return new G4Tet(*this);
}

◆ ComputeDimensions()

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}

◆ CreateNURBS()

G4NURBS * G4Tet::CreateNURBS ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 811 of file G4Tet.cc.

{
  return new G4NURBSbox (fDx, fDy, fDz);
}

◆ CreatePolyhedron()

G4Polyhedron * G4Tet::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 792 of file G4Tet.cc.

{
  G4Polyhedron *ph=new G4Polyhedron;
  G4double xyz[4][3];
  static 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;
}

Referenced by GetPolyhedron().

◆ CreateRotatedVertices()

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

protected

Definition at line 619 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;
}

◆ CVSFileVers()

const char * G4Tet::CVSFileVers ( )

inline

Definition at line 126 of file G4Tet.hh.

127 { return CVSVers; }

◆ CVSHeaderVers()

const char * G4Tet::CVSHeaderVers ( )

inline

Definition at line 124 of file G4Tet.hh.

125 { return "$Id: G4Tet.hh,v 1.11 2010-10-20 08:54:18 gcosmo Exp $"; }

◆ DescribeYourselfTo()

void G4Tet::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 774 of file G4Tet.cc.

{
  scene.AddSolid (*this);
}

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 517 of file G4Tet.cc.

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

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 436 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);
}

◆ DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 598 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;
}

◆ DistanceToOut() [2/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 529 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)
    {
      static 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
}

◆ GetCubicVolume()

G4double G4Tet::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 754 of file G4Tet.cc.

{
  return fCubicVolume;
}

◆ GetEntityType()

G4GeometryType G4Tet::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 650 of file G4Tet.cc.

{
  return G4String("G4Tet");
}

◆ GetExtent()

G4VisExtent G4Tet::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 783 of file G4Tet.cc.

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

◆ GetPointOnSurface()

G4ThreeVector G4Tet::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 718 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 = 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;
}

◆ GetPolyhedron()

G4Polyhedron * G4Tet::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 820 of file G4Tet.cc.

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

◆ GetSurfaceArea()

G4double G4Tet::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 763 of file G4Tet.cc.

{
  return fSurfaceArea;
}

◆ GetVertices()

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

Definition at line 739 of file G4Tet.cc.

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

Referenced by G4GDMLWriteSolids::TetWrite().

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 386 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
  }
}

◆ operator=()

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

Definition at line 234 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;
   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;
}

◆ PrintWarnings()

void G4Tet::PrintWarnings ( G4bool flag )

inline

Definition at line 128 of file G4Tet.hh.

129 { warningFlag=flag; }

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 668 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;
}

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 417 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);
 
  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

◆ G4Tet() [1/3]

◆ ~G4Tet()

◆ G4Tet() [2/3]

◆ G4Tet() [3/3]

Member Function Documentation

◆ CalculateExtent()

◆ CheckDegeneracy()

◆ Clone()

◆ ComputeDimensions()

◆ CreateNURBS()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ CVSFileVers()

◆ CVSHeaderVers()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetEntityType()

◆ GetExtent()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ GetVertices()

◆ Inside()

◆ operator=()

◆ PrintWarnings()

◆ StreamInfo()

◆ SurfaceNormal()