#include <G4Ellipsoid.hh>

Inheritance diagram for G4Ellipsoid:

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

virtual	~G4Ellipsoid ()

G4double	GetDx () const

G4double	GetDy () const

G4double	GetDz () const

G4double	GetSemiAxisMax (G4int i) const

G4double	GetZBottomCut () const

G4double	GetZTopCut () const

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

void	SetZCuts (G4double newzBottomCut, G4double newzTopCut)

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

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

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

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

G4double	DistanceToIn (const G4ThreeVector &p) const

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

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4VSolid *	Clone () const

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

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

G4ThreeVector	GetPointOnSurface () const

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4VisExtent	GetExtent () const

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

	G4Ellipsoid (__void__ &)

	G4Ellipsoid (const G4Ellipsoid &rhs)

G4Ellipsoid &	operator= (const G4Ellipsoid &rhs)

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 void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) 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=nullptr, G4ThreeVector n=nullptr) 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 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)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Additional Inherited Members
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

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

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

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

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

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

◆ ~G4Ellipsoid()

G4Ellipsoid::~G4Ellipsoid ( )

virtual

Definition at line 93 of file G4Ellipsoid.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

◆ 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

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

Referenced by CalculateExtent().

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

◆ Clone()

G4VSolid * G4Ellipsoid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 651 of file G4Ellipsoid.cc.

{
  return new G4Ellipsoid(*this);
}

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

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

Referenced by GetPolyhedron().

◆ DescribeYourselfTo()

void G4Ellipsoid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 859 of file G4Ellipsoid.cc.

{
  scene.AddSolid(*this);
}

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

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

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

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

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

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

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

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

◆ GetSemiAxisMax()

G4double G4Ellipsoid::GetSemiAxisMax ( G4int i ) const

inline

Referenced by G4GDMLWriteParamvol::Ellipsoid_dimensionsWrite(), G4GDMLWriteSolids::EllipsoidWrite(), 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;
}

◆ GetZBottomCut()

G4double G4Ellipsoid::GetZBottomCut ( ) const

inline

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

◆ GetZTopCut()

G4double G4Ellipsoid::GetZTopCut ( ) const

inline

Referenced by G4GDMLWriteParamvol::Ellipsoid_dimensionsWrite(), G4GDMLWriteSolids::EllipsoidWrite(), 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;
}

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

◆ SetSemiAxis()

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

inline

◆ SetZCuts()

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

inline

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

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Ellipsoid() [1/3]

◆ ~G4Ellipsoid()

◆ G4Ellipsoid() [2/3]

◆ G4Ellipsoid() [3/3]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateExtent()

◆ Clone()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetDx()

◆ GetDy()

◆ GetDz()

◆ GetEntityType()

◆ GetExtent()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSemiAxisMax()

◆ GetSurfaceArea()

◆ GetZBottomCut()

◆ GetZTopCut()

◆ Inside()

◆ operator=()

◆ SetSemiAxis()

◆ SetZCuts()

◆ StreamInfo()

◆ SurfaceNormal()