#include <G4EllipticalTube.hh>

Inheritance diagram for G4EllipticalTube:

Public Member Functions
	G4EllipticalTube (const G4String &name, G4double Dx, G4double Dy, G4double Dz)

virtual	~G4EllipticalTube ()

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

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4VisExtent	GetExtent () const

G4double	GetDx () const

G4double	GetDy () const

G4double	GetDz () const

void	SetDx (G4double Dx)

void	SetDy (G4double Dy)

void	SetDz (G4double Dz)

	G4EllipticalTube (__void__ &)

	G4EllipticalTube (const G4EllipticalTube &rhs)

G4EllipticalTube &	operator= (const G4EllipticalTube &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 60 of file G4EllipticalTube.hh.

Constructor & Destructor Documentation

◆ G4EllipticalTube() [1/3]

G4EllipticalTube::G4EllipticalTube	(	const G4String &	name,
		G4double	Dx,
		G4double	Dy,
		G4double	Dz
	)

Definition at line 61 of file G4EllipticalTube.cc.

  : G4VSolid(name), fDx(Dx), fDy(Dy), fDz(Dz)
{
  CheckParameters();
}

◆ ~G4EllipticalTube()

G4EllipticalTube::~G4EllipticalTube ( )

virtual

Definition at line 86 of file G4EllipticalTube.cc.

{
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

◆ G4EllipticalTube() [2/3]

G4EllipticalTube::G4EllipticalTube ( __void__ & a )

Definition at line 75 of file G4EllipticalTube.cc.

  : G4VSolid(a), halfTolerance(0.), fDx(0.), fDy(0.), fDz(0.),
    fRsph(0.), fDDx(0.), fDDy(0.), fSx(0.), fSy(0.), fR(0.),
    fQ1(0.), fQ2(0.), fScratch(0.)
{
}

◆ G4EllipticalTube() [3/3]

G4EllipticalTube::G4EllipticalTube ( const G4EllipticalTube & rhs )

Definition at line 95 of file G4EllipticalTube.cc.

  : G4VSolid(rhs), halfTolerance(rhs.halfTolerance),
    fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz),
    fCubicVolume(rhs.fCubicVolume), fSurfaceArea(rhs.fSurfaceArea),
    fRsph(rhs.fRsph), fDDx(rhs.fDDx), fDDy(rhs.fDDy),
    fSx(rhs.fSx), fSy(rhs.fSy), fR(rhs.fR),
    fQ1(rhs.fQ1), fQ2(rhs.fQ2), fScratch(rhs.fScratch)
{
}

Member Function Documentation

◆ BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 187 of file G4EllipticalTube.cc.

{
  pMin.set(-fDx,-fDy,-fDz);
  pMax.set( fDx, fDy, fDz);
}

Referenced by CalculateExtent().

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 199 of file G4EllipticalTube.cc.

{
  G4ThreeVector bmin, bmax;
  G4bool exist;
 
  // Check bounding box (bbox)
  //
  BoundingLimits(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
#ifdef G4BBOX_EXTENT
  return bbox.CalculateExtent(pAxis,pVoxelLimit, pTransform, pMin, pMax);
#endif
  if (bbox.BoundingBoxVsVoxelLimits(pAxis, pVoxelLimit, pTransform, pMin, pMax))
  {
    return exist = (pMin < pMax) ? true : false;
  }
 
  G4double dx = fDx;
  G4double dy = fDy;
  G4double dz = fDz;
 
  // Set bounding envelope (benv) and calculate extent
  //
  const G4int NSTEPS = 24; // number of steps for whole circle
  G4double ang = twopi/NSTEPS;
 
  G4double sinHalf = std::sin(0.5*ang);
  G4double cosHalf = std::cos(0.5*ang);
  G4double sinStep = 2.*sinHalf*cosHalf;
  G4double cosStep = 1. - 2.*sinHalf*sinHalf;
  G4double sx = dx/cosHalf;
  G4double sy = dy/cosHalf;
 
  G4double sinCur = sinHalf;
  G4double cosCur = cosHalf;
  G4ThreeVectorList baseA(NSTEPS),baseB(NSTEPS);
  for (G4int k=0; k<NSTEPS; ++k)
  {
    baseA[k].set(sx*cosCur,sy*sinCur,-dz);
    baseB[k].set(sx*cosCur,sy*sinCur, dz);
 
    G4double sinTmp = sinCur;
    sinCur = sinCur*cosStep + cosCur*sinStep;
    cosCur = cosCur*cosStep - sinTmp*sinStep;
  }
 
  std::vector<const G4ThreeVectorList *> polygons(2);
  polygons[0] = &baseA;
  polygons[1] = &baseB;
  G4BoundingEnvelope benv(bmin, bmax, polygons);
  exist = benv.CalculateExtent(pAxis, pVoxelLimit, pTransform, pMin, pMax);
  return exist;
}

◆ Clone()

G4VSolid * G4EllipticalTube::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 629 of file G4EllipticalTube.cc.

{
  return new G4EllipticalTube(*this);
}

◆ CreatePolyhedron()

G4Polyhedron * G4EllipticalTube::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 749 of file G4EllipticalTube.cc.

{
  // create cylinder with radius=1...
  //
  G4Polyhedron* eTube = new G4PolyhedronTube(0., 1., fDz);
 
  // apply non-uniform scaling...
  //
  eTube->Transform(G4Scale3D(fDx, fDy, 1.));
  return eTube;
}

Referenced by GetPolyhedron().

◆ DescribeYourselfTo()

void G4EllipticalTube::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 785 of file G4EllipticalTube.cc.

{
  scene.AddSolid (*this);
}

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 433 of file G4EllipticalTube.cc.

{
  // safety distance to bounding box
  G4double distX = std::abs(p.x()) - fDx;
  G4double distY = std::abs(p.y()) - fDy;
  G4double distZ = std::abs(p.z()) - fDz;
  G4double distB = std::max(std::max(distX, distY), distZ);
  // return (distB < 0) ? 0 : distB;
 
  // safety distance to lateral surface
  G4double x = p.x() * fSx;
  G4double y = p.y() * fSy;
  G4double distR = std::sqrt(x * x + y * y) - fR;
 
  // return SafetyToIn
  G4double dist = std::max(distB, distR);
  return (dist < 0) ? 0 : dist;
}

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 349 of file G4EllipticalTube.cc.

{
  G4double offset = 0.;
  G4ThreeVector pcur = p;
 
  // Check if point is flying away
  //
  G4double safex = std::abs(pcur.x()) - fDx;
  G4double safey = std::abs(pcur.y()) - fDy;
  G4double safez = std::abs(pcur.z()) - fDz;
 
  if (safez >= -halfTolerance && pcur.z() * v.z() >= 0.) return kInfinity;
  if (safey >= -halfTolerance && pcur.y() * v.y() >= 0.) return kInfinity;
  if (safex >= -halfTolerance && pcur.x() * v.x() >= 0.) return kInfinity;
 
  // Relocate point, if required
  //
  G4double Dmax = 32. * fRsph;
  if (std::max(std::max(safex, safey), safez) > Dmax)
  {
    offset = (1. - 1.e-08) * pcur.mag() - 2. * fRsph;
    pcur += offset * v;
    G4double dist = DistanceToIn(pcur, v);
    return (dist == kInfinity) ? kInfinity : dist + offset;
  }
 
  // Scale elliptical tube to cylinder
  //
  G4double px = pcur.x() * fSx;
  G4double py = pcur.y() * fSy;
  G4double pz = pcur.z();
  G4double vx = v.x() * fSx;
  G4double vy = v.y() * fSy;
  G4double vz = v.z();
 
  // Set coefficients of quadratic equation: A t^2 + 2B t + C = 0
  //
  G4double rr = px * px + py * py;
  G4double A  = vx * vx + vy * vy;
  G4double B  = px * vx + py * vy;
  G4double C  = rr - fR * fR;
  G4double D  = B * B - A * C;
 
  // Check if point is flying away relative to lateral surface
  //
  G4double distR  = fQ1 * rr - fQ2;
  G4bool parallelToZ = (A < DBL_EPSILON || std::abs(vz) >= 1.);
  if (distR >= -halfTolerance && (B >= 0. || parallelToZ)) return kInfinity;
 
  // Find intersection with Z planes
  //
  G4double invz  = (vz == 0) ? DBL_MAX : -1./vz;
  G4double dz    = std::copysign(fDz, invz);
  G4double tzmin = (pz - dz) * invz;
  G4double tzmax = (pz + dz) * invz;
 
  // Solve qudratic equation. There are two cases special where D <= 0:
  //   1) trajectory parallel to Z axis (A = 0, B = 0, C - any, D = 0)
  //   2) touch (D = 0) or no intersection (D < 0) with lateral surface
  //
  if (parallelToZ) return (tzmin<halfTolerance) ? offset : tzmin + offset; // 1)
  if (D <= A * A * fScratch) return kInfinity; // 2)
 
  // Find roots of quadratic equation
  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 tin  = std::max(tzmin, trmin);
  G4double tout = std::min(tzmax, trmax);
 
  if (tout <= tin + halfTolerance) return kInfinity; // touch or no hit
  return (tin<halfTolerance) ? offset : tin + offset;
}

Referenced by DistanceToIn().

◆ DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 585 of file G4EllipticalTube.cc.

{
#ifdef G4SPECDEBUG
  if( Inside(p) == kOutside )
  {
    std::ostringstream message;
    G4long oldprc = message.precision(16);
    message << "Point p is outside (!?) of solid: " << GetName() << "\n"
            << "Position:\n"
            << "   p.x() = "  << p.x()/mm << " mm\n"
            << "   p.y() = "  << p.y()/mm << " mm\n"
            << "   p.z() = "  << p.z()/mm << " mm";
    message.precision(oldprc) ;
    G4Exception("G4ElliptocalTube::DistanceToOut(p)", "GeomSolids1002",
                JustWarning, message);
    DumpInfo();
  }
#endif
  // safety distance to Z-bases
  G4double distZ = fDz - std::abs(p.z());
 
  // safety distance lateral surface
  G4double x = p.x() * fSx;
  G4double y = p.y() * fSy;
  G4double distR = fR - std::sqrt(x * x + y * y);
 
  // return SafetyToOut
  G4double dist = std::min(distZ, distR);
  return (dist < 0) ? 0 : dist;
}

◆ DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 458 of file G4EllipticalTube.cc.

{
  // Check if point flying away relative to Z planes
  //
  G4double pz = p.z();
  G4double vz = v.z();
  G4double distZ = std::abs(pz) - fDz;
  if (distZ >= -halfTolerance && pz * vz > 0)
  {
    if (calcNorm)
    {
      *validNorm = true;
      n->set(0, 0, (pz < 0) ? -1. : 1.);
    }
    return 0.;
  }
  G4double tzmax = (vz == 0) ? DBL_MAX : (std::copysign(fDz, vz) - pz) / vz;
 
  // Scale elliptical tube to cylinder
  //
  G4double px = p.x() * fSx;
  G4double py = p.y() * fSy;
  G4double vx = v.x() * fSx;
  G4double vy = v.y() * fSy;
 
  // Check if point is flying away relative to lateral surface
  //
  G4double rr = px * px + py * py;
  G4double B  = px * vx + py * vy;
  G4double distR  = fQ1 * rr - fQ2;
  if (distR >= -halfTolerance && B > 0.)
  {
    if (calcNorm)
    {
      *validNorm = true;
      *n = G4ThreeVector(px * fDDy, py * fDDx, 0.).unit();
    }
    return 0.;
  }
 
  // Just in case check if point is outside, normally it should never be
  //
  if (std::max(distZ, distR) > halfTolerance)
  {
#ifdef G4SPECDEBUG
    std::ostringstream message;
    G4long oldprc = message.precision(16);
    message << "Point p is outside (!?) of solid: "
            << GetName() << G4endl;
    message << "Position:  " << p << G4endl;;
    message << "Direction: " << v;
    G4cout.precision(oldprc);
    G4Exception("G4EllipticalTube::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;
  G4double C  = rr - fR * fR;
  G4double D  = B * B - A * C;
 
  // Solve qudratic equation. There are two special cases where D <= 0:
  //   1) trajectory parallel to Z axis (A = 0, B = 0, C - any, D = 0)
  //   2) touch (D = 0) or no intersection (D < 0) with lateral surface
  //
  G4bool parallelToZ = (A < DBL_EPSILON || std::abs(vz) >= 1.);
  if (parallelToZ) // 1)
  {
    if (calcNorm)
    {
      *validNorm = true;
      n->set(0, 0, (vz < 0) ? -1. : 1.);
    }
    return tzmax;
  }
  if (D <= A * A * fScratch) // 2)
  {
    if (calcNorm)
    {
      *validNorm = true;
      *n = G4ThreeVector(px * fDDy, py * fDDx, 0.).unit();
    }
    return 0.;
  }
 
  // Find roots of quadratic equation
  G4double tmp = -B - std::copysign(std::sqrt(D), B);
  G4double t1 = tmp / A;
  G4double t2 = C / tmp;
  G4double trmax = std::max(t1, t2);
 
  // Return distance
  G4double tmax = std::min(tzmax, trmax);
 
  // Set normal, if required, and return distance
  //
  if (calcNorm)
  {
    *validNorm = true;
    G4ThreeVector pnew = p + tmax * v;
    if (tmax == tzmax)
      n->set(0, 0, (pnew.z() < 0) ? -1. : 1.);
    else
      *n = G4ThreeVector(pnew.x() * fDDy, pnew.y() * fDDx, 0.).unit();
  }
  return tmax;
}

◆ GetCubicVolume()

G4double G4EllipticalTube::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Definition at line 638 of file G4EllipticalTube.cc.

{
  if (fCubicVolume == 0.)
  {
    fCubicVolume = twopi * fDx * fDy * fDz;
  }
  return fCubicVolume;
}

◆ GetDx()

G4double G4EllipticalTube::GetDx ( ) const

inline

Referenced by G4GDMLWriteSolids::EltubeWrite(), and G4tgbGeometryDumper::GetSolidParams().

◆ GetDy()

G4double G4EllipticalTube::GetDy ( ) const

inline

Referenced by G4GDMLWriteSolids::EltubeWrite(), and G4tgbGeometryDumper::GetSolidParams().

◆ GetDz()

G4double G4EllipticalTube::GetDz ( ) const

inline

Referenced by G4GDMLWriteSolids::EltubeWrite(), and G4tgbGeometryDumper::GetSolidParams().

◆ GetEntityType()

G4GeometryType G4EllipticalTube::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 620 of file G4EllipticalTube.cc.

{
  return G4String("G4EllipticalTube");
}

◆ GetExtent()

G4VisExtent G4EllipticalTube::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 794 of file G4EllipticalTube.cc.

{
  return G4VisExtent( -fDx, fDx, -fDy, fDy, -fDz, fDz );
}

◆ GetPointOnSurface()

G4ThreeVector G4EllipticalTube::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 706 of file G4EllipticalTube.cc.

{
  // Select surface (0 - base at -Z, 1 - base at +Z, 2 - lateral surface)
  //
  G4double sbase = pi * fDx * fDy;
  G4double ssurf = GetCachedSurfaceArea();
  G4double select = ssurf * G4UniformRand();
 
  G4int k = 0;
  if (select > sbase) k = 1;
  if (select > 2. * sbase) k = 2;
 
  // Pick random point on selected surface (rejection sampling)
  //
  G4ThreeVector p;
  switch (k) {
    case 0: // base at -Z
    {
      G4TwoVector rho = G4RandomPointInEllipse(fDx, fDy);
      p.set(rho.x(), rho.y(), -fDz);
      break;
    }
    case 1: // base at +Z
    {
      G4TwoVector rho = G4RandomPointInEllipse(fDx, fDy);
      p.set(rho.x(), rho.y(), fDz);
      break;
    }
    case 2: // lateral surface
    {
      G4TwoVector rho = G4RandomPointOnEllipse(fDx, fDy);
      p.set(rho.x(), rho.y(), (2. * G4UniformRand() - 1.) * fDz);
      break;
    }
  }
  return p;
}

◆ GetPolyhedron()

G4Polyhedron * G4EllipticalTube::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 765 of file G4EllipticalTube.cc.

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

◆ GetSurfaceArea()

G4double G4EllipticalTube::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 671 of file G4EllipticalTube.cc.

{
  if(fSurfaceArea == 0.)
  {
    fSurfaceArea = GetCachedSurfaceArea();
  }
  return fSurfaceArea;
}

◆ Inside()

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

virtual

Implements G4VSolid.

Definition at line 261 of file G4EllipticalTube.cc.

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

Referenced by DistanceToOut().

◆ operator=()

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

Definition at line 109 of file G4EllipticalTube.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   halfTolerance = rhs.halfTolerance;
   fDx = rhs.fDx;
   fDy = rhs.fDy;
   fDz = rhs.fDz;
   fCubicVolume = rhs.fCubicVolume;
   fSurfaceArea = rhs.fSurfaceArea;
 
   fRsph = rhs.fRsph;
   fDDx  = rhs.fDDx;
   fDDy  = rhs.fDDy;
   fSx   = rhs.fSx;
   fSy   = rhs.fSy;
   fR    = rhs.fR;
   fQ1   = rhs.fQ1;
   fQ2   = rhs.fQ2;
   fScratch = rhs.fScratch;
 
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = nullptr;
 
   return *this;
}

◆ SetDx()

void G4EllipticalTube::SetDx ( G4double Dx )

inline

◆ SetDy()

void G4EllipticalTube::SetDy ( G4double Dy )

inline

◆ SetDz()

void G4EllipticalTube::SetDz ( G4double Dz )

inline

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Definition at line 684 of file G4EllipticalTube.cc.

{
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4EllipticalTube\n"
     << " Parameters: \n"
     << "    length Z: " << fDz/mm << " mm \n"
     << "    lateral surface equation: \n"
     << "       (X / " << fDx << ")^2 + (Y / " << fDy << ")^2 = 1 \n"
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
 
  return os;
}

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 277 of file G4EllipticalTube.cc.

{
  G4ThreeVector norm(0, 0, 0);
  G4int nsurf = 0;
 
  // check lateral surface
  G4double x = p.x() * fSx;
  G4double y = p.y() * fSy;
  G4double distR = fQ1 * (x * x + y * y) - fQ2;
  if (std::abs(distR) <= halfTolerance)
  {
    norm = G4ThreeVector(p.x() * fDDy, p.y() * fDDx, 0.).unit();
    ++nsurf;
  }
 
  // check lateral bases
  G4double distZ = std::abs(p.z()) - fDz;
  if (std::abs(distZ) <= halfTolerance)
  {
    norm.setZ(p.z() < 0 ? -1. : 1.);
    ++nsurf;
  }
 
  // return normal
  if (nsurf == 1) return norm;
  else if (nsurf > 1) return norm.unit(); // edge
  else
  {
    // Point is not on the surface
    //
#ifdef G4SPECDEBUG
    std::ostringstream message;
    G4long oldprc = message.precision(16);
    message << "Point p is not on surface (!?) of solid: "
            << GetName() << G4endl;
    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("G4EllipticalTube::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

◆ G4EllipticalTube() [1/3]

◆ ~G4EllipticalTube()

◆ G4EllipticalTube() [2/3]

◆ G4EllipticalTube() [3/3]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateExtent()

◆ Clone()

◆ CreatePolyhedron()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetDx()

◆ GetDy()

◆ GetDz()

◆ GetEntityType()

◆ GetExtent()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSurfaceArea()

◆ Inside()

◆ operator=()

◆ SetDx()

◆ SetDy()

◆ SetDz()

◆ StreamInfo()

◆ SurfaceNormal()