G4Ellipsoid Class Reference

#include <G4Ellipsoid.hh>

Inheritance diagram for G4Ellipsoid:

Public Member Functions
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const
G4VSolid *	Clone () const
void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
G4Polyhedron *	CreatePolyhedron () const
void	DescribeYourselfTo (G4VGraphicsScene &scene) const
G4double	DistanceToIn (const G4ThreeVector &p) const
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const
G4double	DistanceToOut (const G4ThreeVector &p) const
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const
void	DumpInfo () const
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const
	G4Ellipsoid (__void__ &)
	G4Ellipsoid (const G4Ellipsoid &rhs)
	G4Ellipsoid (const G4String &name, G4double xSemiAxis, G4double ySemiAxis, G4double zSemiAxis, G4double zBottomCut=0., G4double zTopCut=0.)
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
G4double	GetCubicVolume ()
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
G4double	GetDx () const
G4double	GetDy () const
G4double	GetDz () const
G4GeometryType	GetEntityType () const
G4VisExtent	GetExtent () const
G4String	GetName () const
G4ThreeVector	GetPointOnSurface () const
G4Polyhedron *	GetPolyhedron () const
G4double	GetSemiAxisMax (G4int i) const
G4double	GetSurfaceArea ()
G4double	GetTolerance () const
G4double	GetZBottomCut () const
G4double	GetZTopCut () const
EInside	Inside (const G4ThreeVector &p) const
G4Ellipsoid &	operator= (const G4Ellipsoid &rhs)
G4bool	operator== (const G4VSolid &s) const
void	SetName (const G4String &name)
void	SetSemiAxis (G4double x, G4double y, G4double z)
void	SetZCuts (G4double newzBottomCut, G4double newzTopCut)
std::ostream &	StreamInfo (std::ostream &os) const
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const
virtual	~G4Ellipsoid ()

Protected Member Functions
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, 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	ClipCrossSection (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
G4double	kCarTolerance

Private Member Functions
G4ThreeVector	ApproxSurfaceNormal (const G4ThreeVector &p) const
void	CheckParameters ()
void	ClipPolygonToSimpleLimits (G4ThreeVectorList &pPolygon, G4ThreeVectorList &outputPolygon, const G4VoxelLimits &pVoxelLimit) const
G4double	LateralSurfaceArea () const

Private Attributes
G4double	fCubicVolume = 0.0
G4double	fDx
G4double	fDy
G4double	fDz
G4double	fLateralArea = 0.0
G4Polyhedron *	fpPolyhedron = nullptr
G4double	fQ1
G4double	fQ2
G4double	fR
G4bool	fRebuildPolyhedron = false
G4double	fRsph
G4String	fshapeName
G4double	fSurfaceArea = 0.0
G4double	fSx
G4double	fSy
G4double	fSz
G4double	fXmax
G4double	fYmax
G4double	fZBottomCut
G4double	fZDimCut
G4double	fZMidCut
G4double	fZTopCut
G4double	halfTolerance

Detailed Description

Definition at line 63 of file G4Ellipsoid.hh.

Constructor & Destructor Documentation

G4Ellipsoid() [1/3]

G4Ellipsoid::G4Ellipsoid	(	const G4String &	name,
		G4double	xSemiAxis,
		G4double	ySemiAxis,
		G4double	zSemiAxis,
		G4double	zBottomCut = 0.,
		G4double	zTopCut = 0.
	)

Definition at line 67 of file G4Ellipsoid.cc.

  : G4VSolid(name), fDx(xSemiAxis), fDy(ySemiAxis), fDz(zSemiAxis),
    fZBottomCut(zBottomCut), fZTopCut(zTopCut)
{
  CheckParameters();
}

References CheckParameters().

Referenced by Clone().

~G4Ellipsoid()

G4Ellipsoid::~G4Ellipsoid ( )

virtual

Definition at line 93 of file G4Ellipsoid.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

References fpPolyhedron.

G4Ellipsoid() [2/3]

G4Ellipsoid::G4Ellipsoid

(

__void__ &

a

)

Definition at line 84 of file G4Ellipsoid.cc.

  : G4VSolid(a), fDx(0.), fDy(0.), fDz(0.), fZBottomCut(0.), fZTopCut(0.)
{
}

G4Ellipsoid() [3/3]

G4Ellipsoid::G4Ellipsoid

(

const G4Ellipsoid &

rhs

)

Definition at line 102 of file G4Ellipsoid.cc.

  : G4VSolid(rhs),
   fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz),
   fZBottomCut(rhs.fZBottomCut), fZTopCut(rhs.fZTopCut),
   halfTolerance(rhs.halfTolerance),
   fXmax(rhs.fXmax), fYmax(rhs.fYmax),
   fRsph(rhs.fRsph), fR(rhs.fR),
   fSx(rhs.fSx), fSy(rhs.fSy), fSz(rhs.fSz),
   fZMidCut(rhs.fZMidCut), fZDimCut(rhs.fZDimCut),
   fQ1(rhs.fQ1), fQ2(rhs.fQ2),
   fCubicVolume(rhs.fCubicVolume),
   fSurfaceArea(rhs.fSurfaceArea),
   fLateralArea(rhs.fLateralArea)
{
}

Member Function Documentation

ApproxSurfaceNormal()

G4ThreeVector G4Ellipsoid::ApproxSurfaceNormal ( const G4ThreeVector &  p ) const

private

Definition at line 366 of file G4Ellipsoid.cc.

{
  G4double x  = p.x() * fSx;
  G4double y  = p.y() * fSy;
  G4double z  = p.z() * fSz;
  G4double rr = x * x + y * y + z * z;
  G4double distZ = std::abs(z - fZMidCut) - fZDimCut;
  G4double distR = std::sqrt(rr) - fR;
  if  (distR > distZ && rr > 0.) // distR > distZ is correct!
    return G4ThreeVector(x*fSx, y*fSy, z*fSz).unit();
  else
    return G4ThreeVector(0., 0., std::copysign(1., z - fZMidCut));
}

References fR, fSx, fSy, fSz, fZDimCut, fZMidCut, CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOut(), and SurfaceNormal().

BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 264 of file G4Ellipsoid.cc.

{
  pMin.set(-fXmax,-fYmax, fZBottomCut);
  pMax.set( fXmax, fYmax, fZTopCut);
}

References fXmax, fYmax, fZBottomCut, fZTopCut, pMax, and pMin.

Referenced by CalculateExtent().

CalculateClippedPolygonExtent()

void G4VSolid::CalculateClippedPolygonExtent ( G4ThreeVectorList &  pPolygon, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis, G4double &  pMin, G4double &  pMax  ) const

protectedinherited

Definition at line 489 of file G4VSolid.cc.

{
  G4int noLeft,i;
  G4double component;
 
  ClipPolygon(pPolygon,pVoxelLimit,pAxis);
  noLeft = pPolygon.size();
 
  if ( noLeft )
  {
    for (i=0; i<noLeft; ++i)
    {
      component = pPolygon[i].operator()(pAxis);
 
      if (component < pMin)
      {
        pMin = component;
      }
      if (component > pMax)
      {
        pMax = component;
      }
    }
  }
}

References G4VSolid::ClipPolygon(), pMax, and pMin.

Referenced by G4VSolid::ClipBetweenSections(), and G4VSolid::ClipCrossSection().

CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 276 of file G4Ellipsoid.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Get bounding box
  BoundingLimits(bmin,bmax);
 
  // Find extent
  G4BoundingEnvelope bbox(bmin,bmax);
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
}

References BoundingLimits(), G4BoundingEnvelope::CalculateExtent(), pMax, and pMin.

CheckParameters()

void G4Ellipsoid::CheckParameters ( )

private

Definition at line 167 of file G4Ellipsoid.cc.

{
  halfTolerance = 0.5 * kCarTolerance; // half tolerance
  G4double dmin = 2. * kCarTolerance;
 
  // Check dimensions
  //
  if (fDx < dmin || fDy < dmin || fDz < dmin)
  {
    std::ostringstream message;
    message << "Invalid (too small or negative) dimensions for Solid: "
            << GetName()  << "\n"
            << "  semi-axis x: " << fDx << "\n"
            << "  semi-axis y: " << fDy << "\n"
            << "  semi-axis z: " << fDz;
    G4Exception("G4Ellipsoid::CheckParameters()", "GeomSolids0002",
                FatalException, message);
  }
  G4double A = fDx;
  G4double B = fDy;
  G4double C = fDz;
 
  // Check cuts
  //
  if (fZBottomCut == 0. && fZTopCut == 0.)
  {
    fZBottomCut = -C;
    fZTopCut = C;
  }
  if (fZBottomCut >= C || fZTopCut <= -C || fZBottomCut >= fZTopCut)
  {
    std::ostringstream message;
    message << "Invalid Z cuts for Solid: "
            << GetName() << "\n"
            << "  bottom cut: " << fZBottomCut << "\n"
            << "  top cut: " << fZTopCut;
    G4Exception("G4Ellipsoid::CheckParameters()", "GeomSolids0002",
                FatalException, message);
 
  }
  fZBottomCut = std::max(fZBottomCut, -C);
  fZTopCut = std::min(fZTopCut, C);
 
  // Set extent in x and y
  fXmax = A;
  fYmax = B;
  if (fZBottomCut > 0.)
  {
    G4double ratio = fZBottomCut / C;
    G4double scale = std::sqrt((1. - ratio) * (1 + ratio));
    fXmax *= scale;
    fYmax *= scale;
  }
  if (fZTopCut < 0.)
  {
    G4double ratio  = fZTopCut / C;
    G4double scale  = std::sqrt((1. - ratio) * (1 + ratio));
    fXmax *= scale;
    fYmax *= scale;
  }
 
  // Set scale factors
  fRsph = std::max(std::max(A, B), C); // bounding sphere
  fR    = std::min(std::min(A, B), C); // radius of sphere after scaling
  fSx   = fR / A; // X scale factor
  fSy   = fR / B; // Y scale factor
  fSz   = fR / C; // Z scale factor
 
  // Scaled cuts
  fZMidCut = 0.5 * (fZTopCut + fZBottomCut) * fSz; // middle position
  fZDimCut = 0.5 * (fZTopCut - fZBottomCut) * fSz; // half distance
 
  // Coefficients for approximation of distance: Q1 * (x^2 + y^2 + z^2) - Q2
  fQ1 = 0.5 / fR;
  fQ2 = 0.5 * fR + halfTolerance * halfTolerance * fQ1;
 
  fCubicVolume = 0.; // volume
  fSurfaceArea = 0.; // surface area
  fLateralArea = 0.; // lateral surface area
}

References A, B(), C(), FatalException, fCubicVolume, fDx, fDy, fDz, fLateralArea, fQ1, fQ2, fR, fRsph, fSurfaceArea, fSx, fSy, fSz, fXmax, fYmax, fZBottomCut, fZDimCut, fZMidCut, fZTopCut, G4Exception(), G4VSolid::GetName(), halfTolerance, G4VSolid::kCarTolerance, G4INCL::Math::max(), and G4INCL::Math::min().

Referenced by G4Ellipsoid().

ClipBetweenSections()

void G4VSolid::ClipBetweenSections ( G4ThreeVectorList *  pVertices, const G4int  pSectionIndex, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis, G4double &  pMin, G4double &  pMax  ) const

protectedinherited

Definition at line 444 of file G4VSolid.cc.

{
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

ClipCrossSection()

void G4VSolid::ClipCrossSection ( G4ThreeVectorList *  pVertices, const G4int  pSectionIndex, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis, G4double &  pMin, G4double &  pMax  ) const

protectedinherited

Definition at line 414 of file G4VSolid.cc.

{
 
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

ClipPolygon()

void G4VSolid::ClipPolygon ( G4ThreeVectorList &  pPolygon, const G4VoxelLimits &  pVoxelLimit, const EAxis  pAxis  ) const

protectedinherited

Definition at line 539 of file G4VSolid.cc.

{
  G4ThreeVectorList outputPolygon;
 
  if ( pVoxelLimit.IsLimited() )
  {
    if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      // Return after final clip - no cleanup
    }
  }
}

References G4VoxelLimits::AddLimit(), G4VSolid::ClipPolygonToSimpleLimits(), G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), G4VoxelLimits::IsLimited(), G4VoxelLimits::IsXLimited(), G4VoxelLimits::IsYLimited(), G4VoxelLimits::IsZLimited(), kInfinity, kXAxis, kYAxis, and kZAxis.

Referenced by G4VSolid::CalculateClippedPolygonExtent().

ClipPolygonToSimpleLimits()

void G4VSolid::ClipPolygonToSimpleLimits ( G4ThreeVectorList &  pPolygon, G4ThreeVectorList &  outputPolygon, const G4VoxelLimits &  pVoxelLimit  ) const

privateinherited

Definition at line 612 of file G4VSolid.cc.

{
  G4int i;
  G4int noVertices=pPolygon.size();
  G4ThreeVector vEnd,vStart;
 
  for (i = 0 ; i < noVertices ; ++i )
  {
    vStart = pPolygon[i];
    if ( i == noVertices-1 )    vEnd = pPolygon[0];
    else                        vEnd = pPolygon[i+1];
 
    if ( pVoxelLimit.Inside(vStart) )
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart and vEnd inside -> output end point
        //
        outputPolygon.push_back(vEnd);
      }
      else
      {
        // vStart inside, vEnd outside -> output crossing point
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vEnd);
      }
    }
    else
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart outside, vEnd inside -> output inside section
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vStart);
        outputPolygon.push_back(vEnd);
      }
      else  // Both point outside -> no output
      {
        // outputPolygon.push_back(vStart);
        // outputPolygon.push_back(vEnd);
      }
    }
  }
}

References G4VoxelLimits::ClipToLimits(), and G4VoxelLimits::Inside().

Referenced by G4VSolid::ClipPolygon().

Clone()

G4VSolid * G4Ellipsoid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 651 of file G4Ellipsoid.cc.

{
  return new G4Ellipsoid(*this);
}

References G4Ellipsoid().

ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 253 of file G4Ellipsoid.cc.

{
  p->ComputeDimensions(*this,n,pRep);
}

References G4VPVParameterisation::ComputeDimensions(), and CLHEP::detail::n.

CreatePolyhedron()

G4Polyhedron * G4Ellipsoid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 877 of file G4Ellipsoid.cc.

{
  return new G4PolyhedronEllipsoid(fDx, fDy, fDz, fZBottomCut, fZTopCut);
}

References fDx, fDy, fDz, fZBottomCut, and fZTopCut.

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4Ellipsoid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 859 of file G4Ellipsoid.cc.

{
  scene.AddSolid(*this);
}

References G4VGraphicsScene::AddSolid().

DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 470 of file G4Ellipsoid.cc.

{
  G4double px = p.x();
  G4double py = p.y();
  G4double pz = p.z();
 
  // Safety distance to bounding box
  G4double distX = std::abs(px) - fXmax;
  G4double distY = std::abs(py) - fYmax;
  G4double distZ = std::max(pz - fZTopCut, fZBottomCut - pz);
  G4double distB = std::max(std::max(distX, distY), distZ);
 
  // Safety distance to lateral surface
  G4double x = px * fSx;
  G4double y = py * fSy;
  G4double z = pz * fSz;
  G4double distR = std::sqrt(x*x + y*y + z*z) - fR;
 
  // Return safety to in
  G4double dist = std::max(distB, distR);
  return (dist < 0.) ? 0. : dist;
}

References fR, fSx, fSy, fSz, fXmax, fYmax, fZBottomCut, fZTopCut, G4INCL::Math::max(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 384 of file G4Ellipsoid.cc.

{
  G4double offset = 0.;
  G4ThreeVector pcur = p;
 
  // Check if point is flying away, relative to bounding box
  //
  G4double safex = std::abs(p.x()) - fXmax;
  G4double safey = std::abs(p.y()) - fYmax;
  G4double safet = p.z() - fZTopCut;
  G4double safeb = fZBottomCut - p.z();
 
  if (safex >= -halfTolerance && p.x() * v.x() >= 0.) return kInfinity;
  if (safey >= -halfTolerance && p.y() * v.y() >= 0.) return kInfinity;
  if (safet >= -halfTolerance && v.z() >= 0.) return kInfinity;
  if (safeb >= -halfTolerance && v.z() <= 0.) return kInfinity;
 
  // Relocate point, if required
  //
  G4double safe = std::max(std::max(std::max(safex, safey), safet), safeb);
  if (safe > 32. * fRsph)
  {
    offset = (1. - 1.e-08) * safe - 2. * fRsph;
    pcur += offset * v;
    G4double dist = DistanceToIn(pcur, v);
    return (dist == kInfinity) ? kInfinity : dist + offset;
  }
 
  // Scale ellipsoid to sphere
  //
  G4double px = pcur.x() * fSx;
  G4double py = pcur.y() * fSy;
  G4double pz = pcur.z() * fSz;
  G4double vx = v.x() * fSx;
  G4double vy = v.y() * fSy;
  G4double vz = v.z() * fSz;
 
  // Check if point is leaving the solid
  //
  G4double dzcut = fZDimCut;
  G4double pzcut = pz - fZMidCut;
  G4double distZ = std::abs(pzcut) - dzcut;
  if (distZ >= -halfTolerance && pzcut * vz >= 0.) return kInfinity;
 
  G4double rr = px * px + py * py + pz * pz;
  G4double pv = px * vx + py * vy + pz * vz;
  G4double distR = fQ1 * rr - fQ2;
  if (distR >= -halfTolerance && pv >= 0.) return kInfinity;
 
  G4double A = vx * vx + vy * vy + vz * vz;
  G4double B = pv;
  G4double C = rr - fR * fR;
  G4double D = B * B - A * C;
  // scratch^2 = R^2 - (R - halfTolerance)^2 = 2 * R * halfTolerance
  G4double EPS = A * A * fR * kCarTolerance; // discriminant at scratching
  if (D <= EPS) return kInfinity; // no intersection or scratching
 
  // Find intersection with Z planes
  //
  G4double invz  = (vz == 0) ? DBL_MAX : -1./vz;
  G4double dz    = std::copysign(dzcut, invz);
  G4double tzmin = (pzcut - dz) * invz;
  G4double tzmax = (pzcut + dz) * invz;
 
  // Find intersection with lateral surface
  //
  G4double tmp = -B - std::copysign(std::sqrt(D), B);
  G4double t1 = tmp / A;
  G4double t2 = C / tmp;
  G4double trmin = std::min(t1, t2);
  G4double trmax = std::max(t1, t2);
 
  // Return distance
  //
  G4double tmin = std::max(tzmin, trmin);
  G4double tmax = std::min(tzmax, trmax);
 
  if (tmax - tmin <= halfTolerance) return kInfinity; // touch or no hit
  return (tmin < halfTolerance) ? offset : tmin + offset;
}

References A, B(), C(), D(), DBL_MAX, DistanceToIn(), EPS, fQ1, fQ2, fR, fRsph, fSx, fSy, fSz, fXmax, fYmax, fZBottomCut, fZDimCut, fZMidCut, fZTopCut, halfTolerance, G4VSolid::kCarTolerance, kInfinity, G4INCL::Math::max(), G4INCL::Math::min(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToIn().

DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 622 of file G4Ellipsoid.cc.

{
  // Safety distance in z direction
  G4double distZ = std::min(fZTopCut - p.z(), p.z() - fZBottomCut);
 
  // Safety distance to lateral surface
  G4double x = p.x() * fSx;
  G4double y = p.y() * fSy;
  G4double z = p.z() * fSz;
  G4double distR = fR - std::sqrt(x*x + y*y + z*z);
 
  // Return safety to out
  G4double dist = std::min(distZ, distR);
  return (dist < 0.) ? 0. : dist;
}

References fR, fSx, fSy, fSz, fZBottomCut, fZTopCut, G4INCL::Math::min(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 497 of file G4Ellipsoid.cc.

{
  // Check if point flying away relative to Z planes
  //
  G4double pz = p.z() * fSz;
  G4double vz = v.z() * fSz;
  G4double dzcut = fZDimCut;
  G4double pzcut = pz - fZMidCut;
  G4double distZ = std::abs(pzcut) - dzcut;
  if (distZ >= -halfTolerance && pzcut * vz > 0.)
  {
    if (calcNorm)
    {
      *validNorm = true;
      n->set(0., 0., std::copysign(1., pzcut));
    }
    return 0.;
  }
 
  // Check if point is flying away relative to lateral surface
  //
  G4double px = p.x() * fSx;
  G4double py = p.y() * fSy;
  G4double vx = v.x() * fSx;
  G4double vy = v.y() * fSy;
  G4double rr = px * px + py * py + pz * pz;
  G4double pv = px * vx + py * vy + pz * vz;
  G4double distR = fQ1 * rr - fQ2;
  if (distR >= -halfTolerance && pv > 0.)
  {
    if (calcNorm)
    {
      *validNorm = true;
      *n = G4ThreeVector(px*fSx, py*fSy, pz*fSz).unit();
    }
    return 0.;
  }
 
  // Just in case check if point is outside (normally it should never be)
  //
  if (std::max(distZ, distR) > halfTolerance)
  {
#ifdef G4SPECSDEBUG
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Point p is outside (!?) of solid: "
            << GetName() << G4endl;
    message << "Position:  " << p << G4endl;;
    message << "Direction: " << v;
    G4cout.precision(oldprc);
    G4Exception("G4Ellipsoid::DistanceToOut(p,v)", "GeomSolids1002",
                JustWarning, message );
    DumpInfo();
#endif
    if (calcNorm)
    {
      *validNorm = true;
      *n = ApproxSurfaceNormal(p);
    }
    return 0.;
  }
 
  // Set coefficients of quadratic equation: A t^2 + 2B t + C = 0
  //
  G4double A  = vx * vx + vy * vy + vz * vz;
  G4double B  = pv;
  G4double C  = rr - fR * fR;
  G4double D  = B * B - A * C;
  // It is expected that the point is located inside the sphere, so
  // max term in the expression for discriminant is A * R^2 and
  // max calculation error can be derived as follows:
  // A * (1 + 2e) * R^2 * (1 + 2e) = A * R^2 + (4 * A * R^2 * e)
  G4double EPS = 4. * A * fR * fR * DBL_EPSILON; // calculation error
 
  if (D <= EPS) // no intersection
  {
    if (calcNorm)
    {
      *validNorm = true;
      *n = G4ThreeVector(px*fSx, py*fSy, pz*fSz).unit();
    }
    return 0.;
  }
 
  // Find intersection with Z cuts
  //
  G4double tzmax = (vz == 0.) ? DBL_MAX : (std::copysign(dzcut, vz) - pzcut) / vz;
 
  // Find intersection with lateral surface
  //
  G4double tmp = -B - std::copysign(std::sqrt(D), B);
  G4double trmax = (tmp < 0.) ? C/tmp : tmp/A;
 
  // Find distance and set normal, if required
  //
  G4double tmax = std::min(tzmax, trmax);
  //if (tmax < halfTolerance) tmax = 0.;
 
  if (calcNorm)
  {
    *validNorm = true;
    if (tmax == tzmax)
    {
      G4double pznew = pz + tmax * vz;
      n->set(0., 0., (pznew > fZMidCut) ? 1. : -1.);
    }
    else
    {
      G4double nx = (px + tmax * vx) * fSx;
      G4double ny = (py + tmax * vy) * fSy;
      G4double nz = (pz + tmax * vz) * fSz;
      *n = G4ThreeVector(nx, ny, nz).unit();
    }
  }
  return tmax;
}

References A, ApproxSurfaceNormal(), B(), C(), D(), DBL_EPSILON, DBL_MAX, G4VSolid::DumpInfo(), EPS, fQ1, fQ2, fR, fSx, fSy, fSz, fZDimCut, fZMidCut, G4cout, G4endl, G4Exception(), G4VSolid::GetName(), halfTolerance, JustWarning, G4INCL::Math::max(), G4INCL::Math::min(), CLHEP::detail::n, CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

DumpInfo()

void G4VSolid::DumpInfo ( ) const

inlineinherited

Referenced by G4Cons::ApproxSurfaceNormal(), G4CutTubs::ApproxSurfaceNormal(), G4Sphere::ApproxSurfaceNormal(), G4Torus::ApproxSurfaceNormal(), G4Tubs::ApproxSurfaceNormal(), G4ReflectedSolid::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), G4ScaledSolid::BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4Box::BoundingLimits(), G4Cons::BoundingLimits(), G4CutTubs::BoundingLimits(), G4Orb::BoundingLimits(), G4Para::BoundingLimits(), G4Sphere::BoundingLimits(), G4Torus::BoundingLimits(), G4Trap::BoundingLimits(), G4Trd::BoundingLimits(), G4Tubs::BoundingLimits(), G4EllipticalCone::BoundingLimits(), G4ExtrudedSolid::BoundingLimits(), G4GenericPolycone::BoundingLimits(), G4GenericTrap::BoundingLimits(), G4Hype::BoundingLimits(), G4Paraboloid::BoundingLimits(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4ParameterisationBoxX::ComputeDimensions(), G4ParameterisationBoxY::ComputeDimensions(), G4ParameterisationBoxZ::ComputeDimensions(), G4ParameterisationConsRho::ComputeDimensions(), G4ParameterisationConsPhi::ComputeDimensions(), G4ParameterisationConsZ::ComputeDimensions(), G4ParameterisationParaX::ComputeDimensions(), G4ParameterisationParaY::ComputeDimensions(), G4ParameterisationParaZ::ComputeDimensions(), G4ParameterisationPolyconeRho::ComputeDimensions(), G4ParameterisationPolyconePhi::ComputeDimensions(), G4ParameterisationPolyconeZ::ComputeDimensions(), G4ParameterisationPolyhedraRho::ComputeDimensions(), G4ParameterisationPolyhedraPhi::ComputeDimensions(), G4ParameterisationPolyhedraZ::ComputeDimensions(), G4ParameterisationTrdX::ComputeDimensions(), G4ParameterisationTrdY::ComputeDimensions(), G4ParameterisationTrdZ::ComputeDimensions(), G4ParameterisationTubsRho::ComputeDimensions(), G4ParameterisationTubsPhi::ComputeDimensions(), G4ParameterisationTubsZ::ComputeDimensions(), G4ReflectedSolid::ComputeDimensions(), G4DisplacedSolid::ComputeDimensions(), G4ScaledSolid::ComputeDimensions(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4DisplacedSolid::CreatePolyhedron(), G4ScaledSolid::CreatePolyhedron(), G4SubtractionSolid::DistanceToIn(), G4Box::DistanceToOut(), G4Orb::DistanceToOut(), G4Para::DistanceToOut(), G4Trap::DistanceToOut(), G4Trd::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4VTwistedFaceted::DistanceToOut(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Tubs::DistanceToOut(), DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4GenericTrap::DistanceToOut(), export_G4VSolid(), G4Polycone::G4Polycone(), G4Polyhedra::G4Polyhedra(), G4BooleanSolid::GetConstituentSolid(), G4NavigationLogger::PostComputeStepLog(), G4Box::SurfaceNormal(), G4Para::SurfaceNormal(), G4Trap::SurfaceNormal(), G4Trd::SurfaceNormal(), SurfaceNormal(), G4EllipticalCone::SurfaceNormal(), G4EllipticalTube::SurfaceNormal(), G4ExtrudedSolid::SurfaceNormal(), and G4Tet::SurfaceNormal().

EstimateCubicVolume()

G4double G4VSolid::EstimateCubicVolume ( G4int  nStat, G4double  epsilon  ) const

inherited

Definition at line 203 of file G4VSolid.cc.

{
  G4int iInside=0;
  G4double px,py,pz,minX,maxX,minY,maxY,minZ,maxZ,volume,halfepsilon;
  G4ThreeVector p;
  EInside in;
 
  // values needed for CalculateExtent signature
 
  G4VoxelLimits limit;                // Unlimited
  G4AffineTransform origin;
 
  // min max extents of pSolid along X,Y,Z
 
  CalculateExtent(kXAxis,limit,origin,minX,maxX);
  CalculateExtent(kYAxis,limit,origin,minY,maxY);
  CalculateExtent(kZAxis,limit,origin,minZ,maxZ);
 
  // limits
 
  if(nStat < 100)    nStat   = 100;
  if(epsilon > 0.01) epsilon = 0.01;
  halfepsilon = 0.5*epsilon;
 
  for(auto i = 0; i < nStat; ++i )
  {
    px = minX-halfepsilon+(maxX-minX+epsilon)*G4QuickRand();
    py = minY-halfepsilon+(maxY-minY+epsilon)*G4QuickRand();
    pz = minZ-halfepsilon+(maxZ-minZ+epsilon)*G4QuickRand();
    p  = G4ThreeVector(px,py,pz);
    in = Inside(p);
    if(in != kOutside) ++iInside;
  }
  volume = (maxX-minX+epsilon)*(maxY-minY+epsilon)
         * (maxZ-minZ+epsilon)*iInside/nStat;
  return volume;
}

References G4VSolid::CalculateExtent(), epsilon(), G4QuickRand(), G4VSolid::Inside(), kOutside, kXAxis, kYAxis, kZAxis, and maxZ.

Referenced by G4VSolid::GetCubicVolume(), G4BooleanSolid::GetCubicVolume(), and G4VCSGfaceted::GetCubicVolume().

EstimateSurfaceArea()

G4double G4VSolid::EstimateSurfaceArea ( G4int  nStat, G4double  ell  ) const

inherited

Definition at line 265 of file G4VSolid.cc.

{
  static const G4double s2 = 1./std::sqrt(2.);
  static const G4double s3 = 1./std::sqrt(3.);
  static const G4ThreeVector directions[64] =
  {
    G4ThreeVector(  0,  0,  0), G4ThreeVector( -1,  0,  0), // (  ,  ,  ) ( -,  ,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,  ) (-+,  ,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,  ) ( -, -,  )
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,  ) (-+, -,  )
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,  ) ( -, +,  )
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,  ) (-+, +,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,  ) ( -,-+,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,  ) (-+,-+,  )
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,  , -) ( -,  , -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,  , -) (-+,  , -)
    G4ThreeVector(  0,-s2,-s2), G4ThreeVector(-s3,-s3,-s3), // (  , -, -) ( -, -, -)
    G4ThreeVector( s3,-s3,-s3), G4ThreeVector(  0,-s2,-s2), // ( +, -, -) (-+, -, -)
 
    G4ThreeVector(  0, s2,-s2), G4ThreeVector(-s3, s3,-s3), // (  , +, -) ( -, +, -)
    G4ThreeVector( s3, s3,-s3), G4ThreeVector(  0, s2,-s2), // ( +, +, -) (-+, +, -)
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,-+, -) ( -,-+, -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,-+, -) (-+,-+, -)
 
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,  , +) ( -,  , +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,  , +) (-+,  , +)
    G4ThreeVector(  0,-s2, s2), G4ThreeVector(-s3,-s3, s3), // (  , -, +) ( -, -, +)
    G4ThreeVector( s3,-s3, s3), G4ThreeVector(  0,-s2, s2), // ( +, -, +) (-+, -, +)
 
    G4ThreeVector(  0, s2, s2), G4ThreeVector(-s3, s3, s3), // (  , +, +) ( -, +, +)
    G4ThreeVector( s3, s3, s3), G4ThreeVector(  0, s2, s2), // ( +, +, +) (-+, +, +)
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,-+, +) ( -,-+, +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,-+, +) (-+,-+, +)
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector( -1,  0,  0), // (  ,  ,-+) ( -,  ,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,-+) (-+,  ,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,-+) ( -, -,-+)
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,-+) (-+, -,-+)
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,-+) ( -, +,-+)
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,-+) (-+, +,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,-+) ( -,-+,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,-+) (-+,-+,-+)
  };
 
  G4ThreeVector bmin, bmax;
  BoundingLimits(bmin, bmax);
 
  G4double dX = bmax.x() - bmin.x();
  G4double dY = bmax.y() - bmin.y();
  G4double dZ = bmax.z() - bmin.z();
 
  // Define statistics and shell thickness
  //
  G4int npoints = (nstat < 1000) ? 1000 : nstat;
  G4double coeff = 0.5 / std::cbrt(G4double(npoints));
  G4double eps = (ell > 0) ? ell : coeff * std::min(std::min(dX, dY), dZ);
  G4double del = 1.8 * eps; // shold be more than sqrt(3.)
 
  G4double minX = bmin.x() - eps;
  G4double minY = bmin.y() - eps;
  G4double minZ = bmin.z() - eps;
 
  G4double dd = 2. * eps;
  dX += dd;
  dY += dd;
  dZ += dd;
 
  // Calculate surface area
  //
  G4int icount = 0;
  for(auto i = 0; i < npoints; ++i)
  {
    G4double px = minX + dX*G4QuickRand();
    G4double py = minY + dY*G4QuickRand();
    G4double pz = minZ + dZ*G4QuickRand();
    G4ThreeVector p  = G4ThreeVector(px, py, pz);
    EInside in = Inside(p);
    G4double dist = 0;
    if (in == kInside)
    {
      if (DistanceToOut(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kInside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kInside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kInside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kInside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kInside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kInside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToOut(p, v);
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= v.dot(n);
    }
    else if (in == kOutside)
    {
      if (DistanceToIn(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kOutside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kOutside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kOutside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kOutside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kOutside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kOutside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToIn(p, v);
      if (dist == kInfinity) continue;
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= -(v.dot(n));
    }
    if (dist < eps) ++icount;
  }
  return dX*dY*dZ*icount/npoints/dd;
}

References G4VSolid::BoundingLimits(), G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), CLHEP::Hep3Vector::dot(), eps, G4QuickRand(), G4VSolid::Inside(), kInfinity, kInside, kOutside, G4INCL::Math::min(), CLHEP::detail::n, G4VSolid::SurfaceNormal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4VSolid::GetSurfaceArea(), G4MultiUnion::GetSurfaceArea(), and G4VCSGfaceted::GetSurfaceArea().

GetConstituentSolid() [1/2]

G4VSolid * G4VSolid::GetConstituentSolid ( G4int  no )

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 170 of file G4VSolid.cc.

{ return nullptr; }

GetConstituentSolid() [2/2]

const G4VSolid * G4VSolid::GetConstituentSolid ( G4int  no ) const

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 167 of file G4VSolid.cc.

{ return nullptr; }

Referenced by G4BooleanSolid::StackPolyhedron().

GetCubicVolume()

G4double G4Ellipsoid::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 682 of file G4Ellipsoid.cc.

{
  if (fCubicVolume == 0.)
  {
    G4double piAB_3 = CLHEP::pi * fDx * fDy / 3.;
    fCubicVolume = 4. * piAB_3 * fDz;
    if (fZBottomCut > -fDz)
    {
      G4double hbot = 1. + fZBottomCut / fDz;
      fCubicVolume -= piAB_3 * hbot * hbot * (2. * fDz - fZBottomCut);
    }
    if (fZTopCut < fDz)
    {
      G4double htop = 1. - fZTopCut / fDz;
      fCubicVolume -= piAB_3 * htop * htop * (2. * fDz + fZTopCut);
    }
  }
  return fCubicVolume;
}

References fCubicVolume, fDx, fDy, fDz, fZBottomCut, fZTopCut, and CLHEP::pi.

GetDisplacedSolidPtr() [1/2]

G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( )

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 176 of file G4VSolid.cc.

{ return nullptr; }

GetDisplacedSolidPtr() [2/2]

const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( ) const

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 173 of file G4VSolid.cc.

{ return nullptr; }

GetDx()

G4double G4Ellipsoid::GetDx ( ) const

inline

Referenced by GetPointOnSurface(), and StreamInfo().

GetDy()

G4double G4Ellipsoid::GetDy ( ) const

inline

Referenced by GetPointOnSurface(), and StreamInfo().

GetDz()

G4double G4Ellipsoid::GetDz ( ) const

inline

Referenced by GetPointOnSurface(), and StreamInfo().

GetEntityType()

G4GeometryType G4Ellipsoid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 642 of file G4Ellipsoid.cc.

{
  return G4String("G4Ellipsoid");
}

Referenced by StreamInfo().

GetExtent()

G4VisExtent G4Ellipsoid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 868 of file G4Ellipsoid.cc.

{
  return G4VisExtent(-fXmax, fXmax, -fYmax, fYmax, fZBottomCut, fZTopCut);
}

References fXmax, fYmax, fZBottomCut, and fZTopCut.

GetName()

G4String G4VSolid::GetName ( ) const

inlineinherited

Referenced by G4GMocrenFileSceneHandler::AddDetector(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4GMocrenFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4GDMLWriteSolids::AddSolid(), G4NavigationLogger::AlongComputeStepLog(), G4GDMLWriteSolids::BooleanWrite(), G4ReflectedSolid::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), G4ScaledSolid::BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4Box::BoundingLimits(), G4Cons::BoundingLimits(), G4CutTubs::BoundingLimits(), G4Orb::BoundingLimits(), G4Para::BoundingLimits(), G4Sphere::BoundingLimits(), G4Torus::BoundingLimits(), G4Trap::BoundingLimits(), G4Trd::BoundingLimits(), G4Tubs::BoundingLimits(), G4EllipticalCone::BoundingLimits(), G4ExtrudedSolid::BoundingLimits(), G4GenericPolycone::BoundingLimits(), G4GenericTrap::BoundingLimits(), G4Hype::BoundingLimits(), G4Paraboloid::BoundingLimits(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4GDMLWriteSolids::BoxWrite(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4NavigationLogger::CheckDaughterEntryPoint(), G4VDivisionParameterisation::CheckNDivAndWidth(), G4VDivisionParameterisation::CheckOffset(), G4GenericTrap::CheckOrder(), G4Para::CheckParameters(), G4Trap::CheckParameters(), G4Trd::CheckParameters(), CheckParameters(), G4EllipticalTube::CheckParameters(), G4ParameterisationPolyconeRho::CheckParametersValidity(), G4ParameterisationPolyconeZ::CheckParametersValidity(), G4ParameterisationPolyhedraRho::CheckParametersValidity(), G4ParameterisationPolyhedraPhi::CheckParametersValidity(), G4ParameterisationPolyhedraZ::CheckParametersValidity(), G4PhantomParameterisation::CheckVoxelsFillContainer(), G4GenericTrap::ComputeIsTwisted(), G4VoxelNavigation::ComputeSafety(), G4VoxelSafety::ComputeSafety(), G4NavigationLogger::ComputeSafetyLog(), G4ParameterisedNavigation::ComputeStep(), G4ReplicaNavigation::ComputeStep(), G4GDMLWriteSolids::ConeWrite(), G4Polyhedra::Create(), G4GenericPolycone::Create(), G4Polycone::Create(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4ReflectedSolid::CreatePolyhedron(), G4ReflectionFactory::CreateReflectedLV(), G4GenericTrap::CreateTessellatedSolid(), G4GDMLWriteSolids::CutTubeWrite(), G4SolidStore::DeRegister(), G4PhysicalVolumeModel::DescribeSolid(), G4SubtractionSolid::DistanceToIn(), G4Paraboloid::DistanceToIn(), G4TessellatedSolid::DistanceToIn(), G4Box::DistanceToOut(), G4Orb::DistanceToOut(), G4Para::DistanceToOut(), G4Trap::DistanceToOut(), G4Trd::DistanceToOut(), G4EllipticalCone::DistanceToOut(), G4TessellatedSolid::DistanceToOut(), DistanceToOut(), G4EllipticalTube::DistanceToOut(), G4tgbGeometryDumper::DumpMultiUnionVolume(), G4tgbGeometryDumper::DumpScaledVolume(), G4tgbGeometryDumper::DumpSolid(), G4GDMLWriteSolids::ElconeWrite(), G4GDMLWriteSolids::EllipsoidWrite(), G4GDMLWriteSolids::EltubeWrite(), G4PVDivision::ErrorInAxis(), G4ReplicatedSlice::ErrorInAxis(), export_G4VSolid(), G4Box::G4Box(), G4Cons::G4Cons(), G4CutTubs::G4CutTubs(), G4EllipticalCone::G4EllipticalCone(), G4Hype::G4Hype(), G4Para::G4Para(), G4Paraboloid::G4Paraboloid(), G4Polycone::G4Polycone(), G4Polyhedra::G4Polyhedra(), G4Sphere::G4Sphere(), G4Tet::G4Tet(), G4Trap::G4Trap(), G4Tubs::G4Tubs(), G4VParameterisationCons::G4VParameterisationCons(), G4VParameterisationPara::G4VParameterisationPara(), G4VParameterisationPolycone::G4VParameterisationPolycone(), G4VParameterisationPolyhedra::G4VParameterisationPolyhedra(), G4VParameterisationTrd::G4VParameterisationTrd(), G4VTwistedFaceted::G4VTwistedFaceted(), G4GDMLWriteSolids::GenericPolyconeWrite(), G4GDMLWriteSolids::GenTrapWrite(), G4Navigator::GetGlobalExitNormal(), G4Navigator::GetLocalExitNormal(), G4ITNavigator1::GetLocalExitNormal(), G4ITNavigator2::GetLocalExitNormal(), G4BooleanSolid::GetPointOnSurface(), G4PhantomParameterisation::GetReplicaNo(), G4GDMLWriteSolids::HypeWrite(), G4TessellatedSolid::InsideNoVoxels(), G4TessellatedSolid::InsideVoxels(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4GenericTrap::MakeDownFacet(), G4Trap::MakePlanes(), G4GenericTrap::MakeUpFacet(), G4GDMLWriteSolids::MultiUnionWrite(), G4GDMLWriteSolids::OrbWrite(), G4GDMLWriteSolids::ParaboloidWrite(), G4GDMLWriteParamvol::ParametersWrite(), G4GDMLWriteSolids::ParaWrite(), G4GDMLWriteSolids::PolyconeWrite(), G4GDMLWriteSolids::PolyhedraWrite(), G4NavigationLogger::PostComputeStepLog(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::PrintDaughterLog(), G4PseudoScene::ProcessVolume(), G4SolidStore::Register(), G4tgbVolumeMgr::RegisterMe(), G4NavigationLogger::ReportOutsideMother(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), G4GenericPolycone::Reset(), G4Polyhedra::Reset(), G4VoxelSafety::SafetyForVoxelNode(), G4GDMLWriteSolids::ScaledWrite(), G4Torus::SetAllParameters(), G4Tet::SetBoundingLimits(), G4Polycone::SetOriginalParameters(), G4Polyhedra::SetOriginalParameters(), G4TessellatedSolid::SetSolidClosed(), G4Tet::SetVertices(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4GDMLWriteSolids::SphereWrite(), G4BooleanSolid::StackPolyhedron(), G4ReflectedSolid::StreamInfo(), G4BooleanSolid::StreamInfo(), G4DisplacedSolid::StreamInfo(), G4MultiUnion::StreamInfo(), G4ScaledSolid::StreamInfo(), G4Box::StreamInfo(), G4Cons::StreamInfo(), G4CSGSolid::StreamInfo(), G4CutTubs::StreamInfo(), G4Orb::StreamInfo(), G4Para::StreamInfo(), G4Sphere::StreamInfo(), G4Torus::StreamInfo(), G4Trap::StreamInfo(), G4Trd::StreamInfo(), G4Tubs::StreamInfo(), StreamInfo(), G4EllipticalCone::StreamInfo(), G4EllipticalTube::StreamInfo(), G4ExtrudedSolid::StreamInfo(), G4GenericPolycone::StreamInfo(), G4GenericTrap::StreamInfo(), G4Hype::StreamInfo(), G4Paraboloid::StreamInfo(), G4Polycone::StreamInfo(), G4Polyhedra::StreamInfo(), G4TessellatedSolid::StreamInfo(), G4Tet::StreamInfo(), G4TwistedBox::StreamInfo(), G4TwistedTrap::StreamInfo(), G4TwistedTrd::StreamInfo(), G4TwistedTubs::StreamInfo(), G4VCSGfaceted::StreamInfo(), G4VTwistedFaceted::StreamInfo(), G4GDMLRead::StripNames(), SubstractSolids(), G4UnionSolid::SurfaceNormal(), G4Box::SurfaceNormal(), G4Para::SurfaceNormal(), G4Trap::SurfaceNormal(), G4Trd::SurfaceNormal(), SurfaceNormal(), G4EllipticalCone::SurfaceNormal(), G4EllipticalTube::SurfaceNormal(), G4ExtrudedSolid::SurfaceNormal(), G4Tet::SurfaceNormal(), G4GDMLWriteSolids::TessellatedWrite(), G4GDMLWriteSolids::TetWrite(), G4GDMLWriteSolids::TorusWrite(), G4GDMLWriteSolids::TrapWrite(), G4GDMLWriteStructure::TraverseVolumeTree(), G4GDMLWriteSolids::TrdWrite(), G4GDMLWriteSolids::TubeWrite(), G4GDMLWriteSolids::TwistedboxWrite(), G4GDMLWriteSolids::TwistedtrapWrite(), G4GDMLWriteSolids::TwistedtrdWrite(), G4GDMLWriteSolids::TwistedtubsWrite(), G4PhysicalVolumeModel::VisitGeometryAndGetVisReps(), and G4GDMLWriteSolids::XtruWrite().

GetPointOnSurface()

G4ThreeVector G4Ellipsoid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 781 of file G4Ellipsoid.cc.

{
  G4double A    = GetDx();
  G4double B    = GetDy();
  G4double C    = GetDz();
  G4double Zbot = GetZBottomCut();
  G4double Ztop = GetZTopCut();
 
  // Calculate cut areas
  G4double Hbot = 1. + Zbot / C;
  G4double Htop = 1. - Ztop / C;
  G4double piAB = CLHEP::pi * A * B;
  G4double Sbot = piAB * Hbot * (2. - Hbot);
  G4double Stop = piAB * Htop * (2. - Htop);
 
  // Get area of lateral surface
  if (fLateralArea == 0.)
  {
    G4AutoLock l(&lateralareaMutex);
    fLateralArea = LateralSurfaceArea();
    l.unlock();
  }
  G4double Slat = fLateralArea;
 
  // Select surface (0 - bottom cut, 1 - lateral surface, 2 - top cut)
  G4double select = (Sbot + Slat + Stop) * G4QuickRand();
  G4int k = 0;
  if (select > Sbot) k = 1;
  if (select > Sbot + Slat) k = 2;
 
  // Pick random point on selected surface (rejection sampling)
  G4ThreeVector p;
  switch (k)
  {
    case 0: // bootom z-cut
    {
      G4double scale = std::sqrt(Hbot * (2. - Hbot));
      G4TwoVector rho = G4RandomPointInEllipse(A * scale, B * scale);
      p.set(rho.x(), rho.y(), Zbot);
      break;
    }
    case 1: // lateral surface
    {
      G4double x, y, z;
      G4double mu_max = std::max(std::max(A * B, A * C), B * C);
      for (G4int i = 0; i < 1000; ++i)
      {
        // generate random point on unit sphere
        z = (Zbot + (Ztop - Zbot) * G4QuickRand()) / C;
        G4double rho = std::sqrt((1. + z) * (1. - z));
        G4double phi = CLHEP::twopi * G4QuickRand();
        x = rho * std::cos(phi);
        y = rho * std::sin(phi);
        // check  acceptance
        G4double xbc = x * B * C;
        G4double yac = y * A * C;
        G4double zab = z * A * B;
        G4double mu  = std::sqrt(xbc * xbc + yac * yac + zab * zab);
        if (mu_max * G4QuickRand() <= mu) break;
      }
      p.set(A * x, B * y, C * z);
      break;
    }
    case 2: // top z-cut
    {
      G4double scale  = std::sqrt(Htop * (2. - Htop));
      G4TwoVector rho = G4RandomPointInEllipse(A * scale, B * scale);
      p.set(rho.x(), rho.y(), Ztop);
      break;
    }
  }
  return p;
}

References A, B(), C(), fLateralArea, G4QuickRand(), G4RandomPointInEllipse(), GetDx(), GetDy(), GetDz(), GetZBottomCut(), GetZTopCut(), anonymous_namespace{G4Ellipsoid.cc}::lateralareaMutex, LateralSurfaceArea(), G4INCL::Math::max(), CLHEP::pi, CLHEP::Hep3Vector::set(), CLHEP::twopi, G4TemplateAutoLock< _Mutex_t >::unlock(), CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

GetPolyhedron()

G4Polyhedron * G4Ellipsoid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 886 of file G4Ellipsoid.cc.

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

References CreatePolyhedron(), fpPolyhedron, fRebuildPolyhedron, HepPolyhedron::GetNumberOfRotationSteps(), G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation(), anonymous_namespace{G4Ellipsoid.cc}::polyhedronMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

GetSemiAxisMax()

G4double G4Ellipsoid::GetSemiAxisMax ( G4int  i ) const

inline

Referenced by G4GDMLWriteParamvol::Ellipsoid_dimensionsWrite(), G4GDMLWriteSolids::EllipsoidWrite(), export_G4Ellipsoid(), and G4tgbGeometryDumper::GetSolidParams().

GetSurfaceArea()

G4double G4Ellipsoid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 757 of file G4Ellipsoid.cc.

{
  if (fSurfaceArea == 0.)
  {
    G4double piAB = CLHEP::pi * fDx * fDy;
    fSurfaceArea = LateralSurfaceArea();
    if (fZBottomCut > -fDz)
    {
      G4double hbot = 1. + fZBottomCut / fDz;
      fSurfaceArea += piAB * hbot * (2. - hbot);
    }
    if (fZTopCut < fDz)
    {
      G4double htop = 1. - fZTopCut / fDz;
      fSurfaceArea += piAB * htop * (2. - htop);
    }
  }
  return fSurfaceArea;
}

References fDx, fDy, fDz, fSurfaceArea, fZBottomCut, fZTopCut, LateralSurfaceArea(), and CLHEP::pi.

GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

Referenced by G4NavigationLogger::CheckDaughterEntryPoint(), G4ParameterisedNavigation::ComputeStep(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::ReportOutsideMother(), and G4NavigationLogger::ReportVolumeAndIntersection().

GetZBottomCut()

G4double G4Ellipsoid::GetZBottomCut ( ) const

inline

Referenced by G4GDMLWriteParamvol::Ellipsoid_dimensionsWrite(), G4GDMLWriteSolids::EllipsoidWrite(), export_G4Ellipsoid(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), and StreamInfo().

GetZTopCut()

G4double G4Ellipsoid::GetZTopCut ( ) const

inline

Referenced by G4GDMLWriteParamvol::Ellipsoid_dimensionsWrite(), G4GDMLWriteSolids::EllipsoidWrite(), export_G4Ellipsoid(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), and StreamInfo().

Inside()

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

virtual

Implements G4VSolid.

Definition at line 295 of file G4Ellipsoid.cc.

{
  G4double x     = p.x() * fSx;
  G4double y     = p.y() * fSy;
  G4double z     = p.z() * fSz;
  G4double rr    = x * x + y * y + z * z;
  G4double distZ = std::abs(z - fZMidCut) - fZDimCut;
  G4double distR = fQ1 * rr - fQ2;
  G4double dist  = std::max(distZ, distR);
 
  if (dist > halfTolerance) return kOutside;
  return (dist > -halfTolerance) ? kSurface : kInside;
}

References fQ1, fQ2, fSx, fSy, fSz, fZDimCut, fZMidCut, halfTolerance, kInside, kOutside, kSurface, G4INCL::Math::max(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

LateralSurfaceArea()

G4double G4Ellipsoid::LateralSurfaceArea ( ) const

private

Definition at line 706 of file G4Ellipsoid.cc.

{
  const G4int Nphi = 100;
  const G4int Nz   = 200;
  G4double rho[Nz + 1];
 
  // Set array of rho
  G4double zbot = fZBottomCut / fDz;
  G4double ztop = fZTopCut / fDz;
  G4double dz   = (ztop - zbot) / Nz;
  for (G4int iz = 0; iz < Nz; ++iz)
  {
    G4double z = zbot + iz * dz;
    rho[iz] = std::sqrt((1. + z) * (1. - z));
  }
  rho[Nz] = std::sqrt((1. + ztop) * (1. - ztop));
 
  // Compute area
  zbot = fZBottomCut;
  ztop = fZTopCut;
  dz   = (ztop - zbot) / Nz;
  G4double area = 0.;
  G4double dphi = CLHEP::halfpi / Nphi;
  for (G4int iphi = 0; iphi < Nphi; ++iphi)
  {
    G4double phi1 = iphi * dphi;
    G4double phi2 = (iphi == Nphi - 1) ? CLHEP::halfpi : phi1 + dphi;
    G4double cos1 = std::cos(phi1) * fDx;
    G4double cos2 = std::cos(phi2) * fDx;
    G4double sin1 = std::sin(phi1) * fDy;
    G4double sin2 = std::sin(phi2) * fDy;
    for (G4int iz = 0; iz < Nz; ++iz)
    {
      G4double z1   = zbot + iz * dz;
      G4double z2   = (iz == Nz - 1) ? ztop : z1 + dz;
      G4double rho1 = rho[iz];
      G4double rho2 = rho[iz + 1];
      G4ThreeVector p1(rho1 * cos1, rho1 * sin1, z1);
      G4ThreeVector p2(rho1 * cos2, rho1 * sin2, z1);
      G4ThreeVector p3(rho2 * cos1, rho2 * sin1, z2);
      G4ThreeVector p4(rho2 * cos2, rho2 * sin2, z2);
      area += ((p4 - p1).cross(p3 - p2)).mag();
    }
  }
  return 2. * area;
}

References fDx, fDy, fDz, fZBottomCut, fZTopCut, and CLHEP::halfpi.

Referenced by GetPointOnSurface(), and GetSurfaceArea().

operator=()

G4Ellipsoid & G4Ellipsoid::operator=

(

const G4Ellipsoid &

rhs

)

Definition at line 122 of file G4Ellipsoid.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   fDx = rhs.fDx;
   fDy = rhs.fDy;
   fDz = rhs.fDz;
   fZBottomCut = rhs.fZBottomCut;
   fZTopCut = rhs.fZTopCut;
 
   halfTolerance = rhs.halfTolerance;
   fXmax = rhs.fXmax;
   fYmax = rhs.fYmax;
   fRsph = rhs.fRsph;
   fR = rhs.fR;
   fSx = rhs.fSx;
   fSy = rhs.fSy;
   fSz = rhs.fSz;
   fZMidCut = rhs.fZMidCut;
   fZDimCut = rhs.fZDimCut;
   fQ1 = rhs.fQ1;
   fQ2 = rhs.fQ2;
 
   fCubicVolume = rhs.fCubicVolume;
   fSurfaceArea = rhs.fSurfaceArea;
   fLateralArea = rhs.fLateralArea;
 
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   return *this;
}

References fCubicVolume, fDx, fDy, fDz, fLateralArea, fpPolyhedron, fQ1, fQ2, fR, fRebuildPolyhedron, fRsph, fSurfaceArea, fSx, fSy, fSz, fXmax, fYmax, fZBottomCut, fZDimCut, fZMidCut, fZTopCut, halfTolerance, and G4VSolid::operator=().

operator==()

G4bool G4VSolid::operator== ( const G4VSolid &  s ) const

inlineinherited

SetName()

void G4VSolid::SetName ( const G4String &  name )

inherited

Definition at line 127 of file G4VSolid.cc.

{
  fshapeName = name;
  G4SolidStore::GetInstance()->SetMapValid(false);
}

References G4VSolid::fshapeName, G4SolidStore::GetInstance(), G4InuclParticleNames::name(), and G4SolidStore::SetMapValid().

Referenced by export_G4VSolid(), G4MultiUnion::G4MultiUnion(), and G4GDMLRead::StripNames().

SetSemiAxis()

void G4Ellipsoid::SetSemiAxis ( G4double  x, G4double  y, G4double  z  )

inline

Referenced by G4GDMLParameterisation::ComputeDimensions(), and export_G4Ellipsoid().

SetZCuts()

void G4Ellipsoid::SetZCuts ( G4double  newzBottomCut, G4double  newzTopCut  )

inline

Referenced by G4GDMLParameterisation::ComputeDimensions(), and export_G4Ellipsoid().

StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 660 of file G4Ellipsoid.cc.

{
  G4int oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: " << GetEntityType() << "\n"
     << " Parameters: \n"
     << "    semi-axis x: " << GetDx()/mm << " mm \n"
     << "    semi-axis y: " << GetDy()/mm << " mm \n"
     << "    semi-axis z: " << GetDz()/mm << " mm \n"
     << "    lower cut in z: " << GetZBottomCut()/mm << " mm \n"
     << "    upper cut in z: " << GetZTopCut()/mm << " mm \n"
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
  return os;
}

References GetDx(), GetDy(), GetDz(), GetEntityType(), G4VSolid::GetName(), GetZBottomCut(), GetZTopCut(), and mm.

SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 313 of file G4Ellipsoid.cc.

{
  G4ThreeVector norm(0., 0., 0.);
  G4int nsurf = 0;
 
  // Check cuts
  G4double x = p.x() * fSx;
  G4double y = p.y() * fSy;
  G4double z = p.z() * fSz;
  G4double distZ = std::abs(z - fZMidCut) - fZDimCut;
  if (std::abs(distZ) <= halfTolerance)
  {
    norm.setZ(std::copysign(1., z - fZMidCut));
    ++nsurf;
  }
 
  // Check lateral surface
  G4double distR = fQ1*(x*x + y*y + z*z) - fQ2;
  if (std::abs(distR) <= halfTolerance)
  {
    // normal = (p.x/a^2, p.y/b^2, p.z/c^2)
    norm += G4ThreeVector(x*fSx, y*fSy, z*fSz).unit();
    ++nsurf;
  }
 
  // Return normal
  if (nsurf == 1) return norm;
  else if (nsurf > 1) return norm.unit(); // edge
  else
  {
#ifdef G4SPECSDEBUG
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Point p is not on surface (!?) of solid: "
            << GetName() << "\n";
    message << "Position:\n";
    message << "   p.x() = " << p.x()/mm << " mm\n";
    message << "   p.y() = " << p.y()/mm << " mm\n";
    message << "   p.z() = " << p.z()/mm << " mm";
    G4cout.precision(oldprc);
    G4Exception("G4Ellipsoid::SurfaceNormal(p)", "GeomSolids1002",
                JustWarning, message );
    DumpInfo();
#endif
    return ApproxSurfaceNormal(p);
  }
}

References ApproxSurfaceNormal(), G4VSolid::DumpInfo(), fQ1, fQ2, fSx, fSy, fSz, fZDimCut, fZMidCut, G4cout, G4Exception(), G4VSolid::GetName(), halfTolerance, JustWarning, mm, CLHEP::Hep3Vector::setZ(), CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Field Documentation

fCubicVolume

G4double G4Ellipsoid::fCubicVolume = 0.0

private

Definition at line 177 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), GetCubicVolume(), and operator=().

fDx

G4double G4Ellipsoid::fDx

private

Definition at line 157 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), CreatePolyhedron(), GetCubicVolume(), GetSurfaceArea(), LateralSurfaceArea(), and operator=().

fDy

G4double G4Ellipsoid::fDy

private

Definition at line 158 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), CreatePolyhedron(), GetCubicVolume(), GetSurfaceArea(), LateralSurfaceArea(), and operator=().

fDz

G4double G4Ellipsoid::fDz

private

Definition at line 159 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), CreatePolyhedron(), GetCubicVolume(), GetSurfaceArea(), LateralSurfaceArea(), and operator=().

fLateralArea

G4double G4Ellipsoid::fLateralArea = 0.0

mutableprivate

Definition at line 179 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), GetPointOnSurface(), and operator=().

fpPolyhedron

G4Polyhedron* G4Ellipsoid::fpPolyhedron = nullptr

mutableprivate

Definition at line 181 of file G4Ellipsoid.hh.

Referenced by GetPolyhedron(), operator=(), and ~G4Ellipsoid().

fQ1

G4double G4Ellipsoid::fQ1

private

Definition at line 174 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fQ2

G4double G4Ellipsoid::fQ2

private

Definition at line 175 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fR

G4double G4Ellipsoid::fR

private

Definition at line 168 of file G4Ellipsoid.hh.

Referenced by ApproxSurfaceNormal(), CheckParameters(), DistanceToIn(), DistanceToOut(), and operator=().

fRebuildPolyhedron

G4bool G4Ellipsoid::fRebuildPolyhedron = false

mutableprivate

Definition at line 180 of file G4Ellipsoid.hh.

Referenced by GetPolyhedron(), and operator=().

fRsph

G4double G4Ellipsoid::fRsph

private

Definition at line 167 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), DistanceToIn(), and operator=().

fshapeName

G4String G4VSolid::fshapeName

privateinherited

Definition at line 312 of file G4VSolid.hh.

Referenced by G4VSolid::operator=(), and G4VSolid::SetName().

fSurfaceArea

G4double G4Ellipsoid::fSurfaceArea = 0.0

private

Definition at line 178 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), GetSurfaceArea(), and operator=().

fSx

G4double G4Ellipsoid::fSx

private

Definition at line 169 of file G4Ellipsoid.hh.

Referenced by ApproxSurfaceNormal(), CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fSy

G4double G4Ellipsoid::fSy

private

Definition at line 170 of file G4Ellipsoid.hh.

Referenced by ApproxSurfaceNormal(), CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fSz

G4double G4Ellipsoid::fSz

private

Definition at line 171 of file G4Ellipsoid.hh.

Referenced by ApproxSurfaceNormal(), CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fXmax

G4double G4Ellipsoid::fXmax

private

Definition at line 165 of file G4Ellipsoid.hh.

Referenced by BoundingLimits(), CheckParameters(), DistanceToIn(), GetExtent(), and operator=().

fYmax

G4double G4Ellipsoid::fYmax

private

Definition at line 166 of file G4Ellipsoid.hh.

Referenced by BoundingLimits(), CheckParameters(), DistanceToIn(), GetExtent(), and operator=().

fZBottomCut

G4double G4Ellipsoid::fZBottomCut

private

Definition at line 160 of file G4Ellipsoid.hh.

Referenced by BoundingLimits(), CheckParameters(), CreatePolyhedron(), DistanceToIn(), DistanceToOut(), GetCubicVolume(), GetExtent(), GetSurfaceArea(), LateralSurfaceArea(), and operator=().

fZDimCut

G4double G4Ellipsoid::fZDimCut

private

Definition at line 173 of file G4Ellipsoid.hh.

Referenced by ApproxSurfaceNormal(), CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fZMidCut

G4double G4Ellipsoid::fZMidCut

private

Definition at line 172 of file G4Ellipsoid.hh.

Referenced by ApproxSurfaceNormal(), CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

fZTopCut

G4double G4Ellipsoid::fZTopCut

private

Definition at line 161 of file G4Ellipsoid.hh.

Referenced by BoundingLimits(), CheckParameters(), CreatePolyhedron(), DistanceToIn(), DistanceToOut(), GetCubicVolume(), GetExtent(), GetSurfaceArea(), LateralSurfaceArea(), and operator=().

halfTolerance

G4double G4Ellipsoid::halfTolerance

private

Definition at line 164 of file G4Ellipsoid.hh.

Referenced by CheckParameters(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

kCarTolerance

G4double G4VSolid::kCarTolerance

protectedinherited

Definition at line 299 of file G4VSolid.hh.

Referenced by G4TessellatedSolid::AddFacet(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4Tet::CheckDegeneracy(), G4Para::CheckParameters(), G4Trd::CheckParameters(), CheckParameters(), G4EllipticalTube::CheckParameters(), G4GenericTrap::ComputeIsTwisted(), G4Polyhedra::Create(), G4GenericPolycone::Create(), G4Polycone::Create(), G4CutTubs::CreatePolyhedron(), G4TessellatedSolid::CreateVertexList(), G4VCSGfaceted::DistanceTo(), G4Sphere::DistanceToIn(), DistanceToIn(), G4Hype::DistanceToIn(), G4Paraboloid::DistanceToIn(), G4VCSGfaceted::DistanceToIn(), G4TessellatedSolid::DistanceToInCore(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Tubs::DistanceToOut(), G4GenericTrap::DistanceToOut(), G4Hype::DistanceToOut(), G4Paraboloid::DistanceToOut(), G4VCSGfaceted::DistanceToOut(), G4TessellatedSolid::DistanceToOutCandidates(), G4TessellatedSolid::DistanceToOutCore(), G4TessellatedSolid::DistanceToOutNoVoxels(), G4GenericTrap::DistToPlane(), G4GenericTrap::DistToTriangle(), G4Box::G4Box(), G4Cons::G4Cons(), G4CutTubs::G4CutTubs(), G4EllipticalCone::G4EllipticalCone(), G4ExtrudedSolid::G4ExtrudedSolid(), G4GenericTrap::G4GenericTrap(), G4Hype::G4Hype(), G4Para::G4Para(), G4Sphere::G4Sphere(), G4Tet::G4Tet(), G4Trap::G4Trap(), G4Tubs::G4Tubs(), G4UnionSolid::G4UnionSolid(), G4VSolid::G4VSolid(), G4VTwistedFaceted::G4VTwistedFaceted(), G4GenericPolycone::GetPointOnSurface(), G4Polycone::GetPointOnSurface(), G4UnionSolid::Init(), G4Orb::Initialize(), G4TessellatedSolid::Initialize(), G4SubtractionSolid::Inside(), G4Hype::Inside(), G4Paraboloid::Inside(), G4VCSGfaceted::Inside(), G4VTwistedFaceted::Inside(), G4TessellatedSolid::InsideNoVoxels(), G4GenericTrap::InsidePolygone(), G4TessellatedSolid::InsideVoxels(), G4CutTubs::IsCrossingCutPlanes(), G4GenericTrap::IsSegCrossingZ(), G4Trap::MakePlane(), G4GenericTrap::NormalToPlane(), G4VSolid::operator=(), G4TessellatedSolid::SafetyFromInside(), G4TessellatedSolid::SafetyFromOutside(), G4Torus::SetAllParameters(), G4Polycone::SetOriginalParameters(), G4Polyhedra::SetOriginalParameters(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4Torus::SurfaceNormal(), G4GenericTrap::SurfaceNormal(), and G4Paraboloid::SurfaceNormal().

---

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

• source/geometry/solids/specific/include/G4Ellipsoid.hh
• source/geometry/solids/specific/src/G4Ellipsoid.cc