G4Para represents a parallelepiped, essentially a box with half lengths dx,dy,dz 'skewed' so that there are angles theta & phi of the polar line joining the faces at +-dz in z, and alpha formed by the y axis and the plane joining the centre of the faces parallel to the z-x plane at -dy and +dy. More...

#include <G4Para.hh>

Inheritance diagram for G4Para:

Public Member Functions
	G4Para (const G4String &pName, G4double pDx, G4double pDy, G4double pDz, G4double pAlpha, G4double pTheta, G4double pPhi)
	G4Para (const G4String &pName, const G4ThreeVector pt[8])
	~G4Para () override=default
G4double	GetZHalfLength () const
G4ThreeVector	GetSymAxis () const
G4double	GetYHalfLength () const
G4double	GetXHalfLength () const
G4double	GetTanAlpha () const
G4double	GetAlpha () const
G4double	GetTheta () const
G4double	GetPhi () const
void	SetXHalfLength (G4double val)
void	SetYHalfLength (G4double val)
void	SetZHalfLength (G4double val)
void	SetAlpha (G4double alpha)
void	SetTanAlpha (G4double val)
void	SetThetaAndPhi (G4double pTheta, G4double pPhi)
void	SetAllParameters (G4double pDx, G4double pDy, G4double pDz, G4double pAlpha, G4double pTheta, G4double pPhi)
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep) override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=nullptr, G4ThreeVector n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
G4GeometryType	GetEntityType () const override
G4ThreeVector	GetPointOnSurface () const override
G4bool	IsFaceted () const override
G4VSolid *	Clone () const override
std::ostream &	StreamInfo (std::ostream &os) const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
	G4Para (__void__ &)
	G4Para (const G4Para &rhs)
G4Para &	operator= (const G4Para &rhs)
Public Member Functions inherited from G4CSGSolid
	G4CSGSolid (const G4String &pName)
	~G4CSGSolid () override
G4Polyhedron *	GetPolyhedron () const override
	G4CSGSolid (__void__ &)
	G4CSGSolid (const G4CSGSolid &rhs)
G4CSGSolid &	operator= (const G4CSGSolid &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual G4int	GetNumOfConstituents () const
void	DumpInfo () const
virtual G4VisExtent	GetExtent () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Additional Inherited Members
Protected Member Functions inherited from G4CSGSolid
G4double	GetRadiusInRing (G4double rmin, G4double rmax) const
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const
Protected Attributes inherited from G4CSGSolid
G4double	fCubicVolume = 0.0
G4double	fSurfaceArea = 0.0
G4bool	fRebuildPolyhedron = false
G4Polyhedron *	fpPolyhedron = nullptr
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

G4Para represents a parallelepiped, essentially a box with half lengths dx,dy,dz 'skewed' so that there are angles theta & phi of the polar line joining the faces at +-dz in z, and alpha formed by the y axis and the plane joining the centre of the faces parallel to the z-x plane at -dy and +dy.

Definition at line 85 of file G4Para.hh.

Constructor & Destructor Documentation

◆ G4Para() [1/4]

G4Para::G4Para	(	const G4String &	pName,
		G4double	pDx,
		G4double	pDy,
		G4double	pDz,
		G4double	pAlpha,
		G4double	pTheta,
		G4double	pPhi )

Constructs a parallelepiped, given a name and its parameters.

Parameters

[in]	pName	The name of the solid.
[in]	pDx	Half-length in x.
[in]	pDy	Half-length in y.
[in]	pDz	Half-length in z.
[in]	pAlpha	Angle formed by the Y axis and by the plane joining the centre of the faces parallel to the Z-X plane at -dy and +dy.
[in]	pTheta	Polar angle of the line joining the centres of the faces at -dz and +dz in Z.
[in]	pPhi	Azimuthal angle of the line joining the centres of the faces at -dz and +dz in Z.

Definition at line 59 of file G4Para.cc.

  : G4CSGSolid(pName), halfCarTolerance(0.5*kCarTolerance)
{
  SetAllParameters(pDx, pDy, pDz, pAlpha, pTheta, pPhi);
  fRebuildPolyhedron = false;  // default value for G4CSGSolid
}

Referenced by Clone(), G4Para(), operator=(), and SetThetaAndPhi().

◆ G4Para() [2/4]

G4Para::G4Para	(	const G4String &	pName,
		const G4ThreeVector	pt[8] )

Constructs a parallelepiped, given a name and its 8 vertices.

Parameters

[in]	pName	The name of the solid.
[in]	pt	Points of the 8 vertices.

Definition at line 72 of file G4Para.cc.

  : G4CSGSolid(pName), halfCarTolerance(0.5*kCarTolerance)
{
  // Find dimensions and trigonometric values
  //
  fDx = (pt[3].x() - pt[2].x())*0.5;
  fDy = (pt[2].y() - pt[1].y())*0.5;
  fDz = pt[7].z();
  CheckParameters(); // check dimensions
 
  fTalpha = (pt[2].x() + pt[3].x() - pt[1].x() - pt[0].x())*0.25/fDy;
  fTthetaCphi = (pt[4].x() + fDy*fTalpha + fDx)/fDz;
  fTthetaSphi = (pt[4].y() + fDy)/fDz;
  MakePlanes();
 
  // Recompute vertices
  //
  G4ThreeVector v[8];
  G4double DyTalpha = fDy*fTalpha;
  G4double DzTthetaSphi = fDz*fTthetaSphi;
  G4double DzTthetaCphi = fDz*fTthetaCphi;
  v[0].set(-DzTthetaCphi-DyTalpha-fDx, -DzTthetaSphi-fDy, -fDz);
  v[1].set(-DzTthetaCphi-DyTalpha+fDx, -DzTthetaSphi-fDy, -fDz);
  v[2].set(-DzTthetaCphi+DyTalpha-fDx, -DzTthetaSphi+fDy, -fDz);
  v[3].set(-DzTthetaCphi+DyTalpha+fDx, -DzTthetaSphi+fDy, -fDz);
  v[4].set( DzTthetaCphi-DyTalpha-fDx,  DzTthetaSphi-fDy,  fDz);
  v[5].set( DzTthetaCphi-DyTalpha+fDx,  DzTthetaSphi-fDy,  fDz);
  v[6].set( DzTthetaCphi+DyTalpha-fDx,  DzTthetaSphi+fDy,  fDz);
  v[7].set( DzTthetaCphi+DyTalpha+fDx,  DzTthetaSphi+fDy,  fDz);
 
  // Compare with original vertices
  //
  for (G4int i=0; i<8; ++i)
  {
    G4double delx = std::abs(pt[i].x() - v[i].x());
    G4double dely = std::abs(pt[i].y() - v[i].y());
    G4double delz = std::abs(pt[i].z() - v[i].z());
    G4double discrepancy = std::max(std::max(delx,dely),delz);
    if (discrepancy > 0.1*kCarTolerance)
    {
      std::ostringstream message;
      G4long oldprc = message.precision(16);
      message << "Invalid vertice coordinates for Solid: " << GetName()
              << "\nVertix #" << i << ", discrepancy = " << discrepancy
              << "\n  original   : " << pt[i]
              << "\n  recomputed : " << v[i];
      G4cout.precision(oldprc);
      G4Exception("G4Para::G4Para()", "GeomSolids0002",
                  FatalException, message);
 
    }
  }
}

◆ ~G4Para()

G4Para::~G4Para ( )

overridedefault

Default destructor.

◆ G4Para() [3/4]

G4Para::G4Para ( __void__ & a )

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 132 of file G4Para.cc.

  : G4CSGSolid(a), halfCarTolerance(0.5*kCarTolerance)
{
  SetAllParameters(1., 1., 1., 0., 0., 0.);
  fRebuildPolyhedron = false; // default value for G4CSGSolid
}

◆ G4Para() [4/4]

G4Para::G4Para ( const G4Para & rhs )

Copy constructor and assignment operator.

Definition at line 143 of file G4Para.cc.

  : G4CSGSolid(rhs), halfCarTolerance(rhs.halfCarTolerance),
    fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz), fTalpha(rhs.fTalpha),
    fTthetaCphi(rhs.fTthetaCphi),fTthetaSphi(rhs.fTthetaSphi)
{
  for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs.fPlanes[i]; }
}

Member Function Documentation

◆ BoundingLimits()

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

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 279 of file G4Para.cc.

{
  G4double dz = GetZHalfLength();
  G4double dx = GetXHalfLength();
  G4double dy = GetYHalfLength();
 
  G4double x0 = dz*fTthetaCphi;
  G4double x1 = dy*GetTanAlpha();
  G4double xmin =
    std::min(
    std::min(
    std::min(-x0-x1-dx,-x0+x1-dx),x0-x1-dx),x0+x1-dx);
  G4double xmax =
    std::max(
    std::max(
    std::max(-x0-x1+dx,-x0+x1+dx),x0-x1+dx),x0+x1+dx);
 
  G4double y0 = dz*fTthetaSphi;
  G4double ymin = std::min(-y0-dy,y0-dy);
  G4double ymax = std::max(-y0+dy,y0+dy);
 
  pMin.set(xmin,ymin,-dz);
  pMax.set(xmax,ymax, dz);
 
  // Check correctness of the bounding box
  //
  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
  {
    std::ostringstream message;
    message << "Bad bounding box (min >= max) for solid: "
            << GetName() << " !"
            << "\npMin = " << pMin
            << "\npMax = " << pMax;
    G4Exception("G4Para::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent().

◆ CalculateExtent()

G4bool G4Para::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pMin,
		G4double &	pMax ) const

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns: True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 322 of file G4Para.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;
  }
 
  // Set bounding envelope (benv) and calculate extent
  //
  G4double dz = GetZHalfLength();
  G4double dx = GetXHalfLength();
  G4double dy = GetYHalfLength();
 
  G4double x0 = dz*fTthetaCphi;
  G4double x1 = dy*GetTanAlpha();
  G4double y0 = dz*fTthetaSphi;
 
  G4ThreeVectorList baseA(4), baseB(4);
  baseA[0].set(-x0-x1-dx,-y0-dy,-dz);
  baseA[1].set(-x0-x1+dx,-y0-dy,-dz);
  baseA[2].set(-x0+x1+dx,-y0+dy,-dz);
  baseA[3].set(-x0+x1-dx,-y0+dy,-dz);
 
  baseB[0].set(+x0-x1-dx, y0-dy, dz);
  baseB[1].set(+x0-x1+dx, y0-dy, dz);
  baseB[2].set(+x0+x1+dx, y0+dy, dz);
  baseB[3].set(+x0+x1-dx, y0+dy, dz);
 
  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 * G4Para::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns: A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 786 of file G4Para.cc.

{
  return new G4Para(*this);
}

◆ ComputeDimensions()

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

overridevirtual

Dispatch method for parameterisation replication mechanism and dimension computation.

Reimplemented from G4VSolid.

Definition at line 268 of file G4Para.cc.

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

◆ CreatePolyhedron()

G4Polyhedron * G4Para::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 898 of file G4Para.cc.

{
  G4double phi = std::atan2(fTthetaSphi, fTthetaCphi);
  G4double alpha = std::atan(fTalpha);
  G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi +
                                       fTthetaSphi*fTthetaSphi));
 
  return new G4PolyhedronPara(fDx, fDy, fDz, alpha, theta, phi);
}

◆ DescribeYourselfTo()

void G4Para::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 893 of file G4Para.cc.

{
  scene.AddSolid (*this);
}

◆ DistanceToIn() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Parameters

[in] p The point at offset p.

Returns: The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 604 of file G4Para.cc.

{
  G4double xx = fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z();
  G4double dx = std::abs(xx) + fPlanes[2].d;
 
  G4double yy = fPlanes[0].b*p.y()+fPlanes[0].c*p.z();
  G4double dy = std::abs(yy) + fPlanes[0].d;
  G4double dxy = std::max(dx,dy);
 
  G4double dz = std::abs(p.z())-fDz;
  G4double dist = std::max(dxy,dz);
 
  return (dist > 0) ? dist : 0.;
}

◆ DistanceToIn() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from the point at offset 'p'. If there is no intersection, returns kInfinity. The first intersection resulting from 'leaving' a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.

Returns: The distance to enter the shape.

Implements G4VSolid.

Definition at line 510 of file G4Para.cc.

{
  // Z intersections
  //
  if ((std::abs(p.z()) - fDz) >= -halfCarTolerance && p.z()*v.z() >= 0)
  {
    return kInfinity;
  }
 
  G4double invz = (-v.z() == 0) ? DBL_MAX : -1./v.z();
  G4double dz = (invz < 0) ? fDz : -fDz;
  G4double tzmin = (p.z() + dz)*invz;
  G4double tzmax = (p.z() - dz)*invz;
 
  // Y intersections
  //
  G4double tmin0 = tzmin, tmax0 = tzmax;
  G4double cos0 = fPlanes[0].b*v.y() + fPlanes[0].c*v.z();
  G4double disy = fPlanes[0].b*p.y() + fPlanes[0].c*p.z();
  G4double dis0 = fPlanes[0].d + disy;
  if (dis0 >= -halfCarTolerance)
  {
    if (cos0 >= 0) { return kInfinity; }
    G4double tmp  = -dis0/cos0;
    if (tmin0 < tmp) { tmin0 = tmp; }
  }
  else if (cos0 > 0)
  {
    G4double tmp  = -dis0/cos0;
    if (tmax0 > tmp) { tmax0 = tmp; }
  }
 
  G4double tmin1 = tmin0, tmax1 = tmax0;
  G4double cos1 = -cos0;
  G4double dis1 = fPlanes[1].d - disy;
  if (dis1 >= -halfCarTolerance)
  {
    if (cos1 >= 0) { return kInfinity; }
    G4double tmp  = -dis1/cos1;
    if (tmin1 < tmp) { tmin1 = tmp; }
  }
  else if (cos1 > 0)
  {
    G4double tmp  = -dis1/cos1;
    if (tmax1 > tmp) { tmax1 = tmp; }
  }
 
  // X intersections
  //
  G4double tmin2 = tmin1, tmax2 = tmax1;
  G4double cos2 = fPlanes[2].a*v.x() + fPlanes[2].b*v.y() + fPlanes[2].c*v.z();
  G4double disx = fPlanes[2].a*p.x() + fPlanes[2].b*p.y() + fPlanes[2].c*p.z();
  G4double dis2 = fPlanes[2].d + disx;
  if (dis2 >= -halfCarTolerance)
  {
    if (cos2 >= 0) { return kInfinity; }
    G4double tmp  = -dis2/cos2;
    if (tmin2 < tmp) { tmin2 = tmp; }
  }
  else if (cos2 > 0)
  {
    G4double tmp  = -dis2/cos2;
    if (tmax2 > tmp) { tmax2 = tmp; }
  }
 
  G4double tmin3 = tmin2, tmax3 = tmax2;
  G4double cos3 = -cos2;
  G4double dis3 = fPlanes[3].d - disx;
  if (dis3 >= -halfCarTolerance)
  {
    if (cos3 >= 0) { return kInfinity; }
    G4double tmp  = -dis3/cos3;
    if (tmin3 < tmp) { tmin3 = tmp; }
  }
  else if (cos3 > 0)
  {
    G4double tmp  = -dis3/cos3;
    if (tmax3 > tmp) { tmax3 = tmp; }
  }
 
  // Find distance
  //
  G4double tmin = tmin3, tmax = tmax3;
  if (tmax <= tmin + halfCarTolerance) { return kInfinity; } // touch or no hit
 
  return (tmin < halfCarTolerance ) ? 0. : tmin;
}

◆ DistanceToOut() [1/2]

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

overridevirtual

Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.

Parameters

[in] p The point at offset p.

Returns: The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 733 of file G4Para.cc.

{
#ifdef G4CSGDEBUG
  if( Inside(p) == kOutside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Point p is outside (!?) 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("G4Para::DistanceToOut(p)", "GeomSolids1002",
                JustWarning, message );
    DumpInfo();
    }
#endif
  G4double xx = fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z();
  G4double dx = std::abs(xx) + fPlanes[2].d;
 
  G4double yy = fPlanes[0].b*p.y()+fPlanes[0].c*p.z();
  G4double dy = std::abs(yy) + fPlanes[0].d;
  G4double dxy = std::max(dx,dy);
 
  G4double dz = std::abs(p.z())-fDz;
  G4double dist = std::max(dxy,dz);
 
  return (dist < 0) ? -dist : 0.;
}

◆ DistanceToOut() [2/2]

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

overridevirtual

Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.

Parameters

[in]	p	The point at offset p.
[in]	v	The normalised direction vector.
[in]	calcNorm	Flag to indicate if to calculate the normal or not.
[out]	validNorm	Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused.
[out]	n	The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.

Returns: The distance to exit the shape.

Implements G4VSolid.

Definition at line 625 of file G4Para.cc.

{
  // Z intersections
  //
  if ((std::abs(p.z()) - fDz) >= -halfCarTolerance && p.z()*v.z() > 0)
  {
    if (calcNorm)
    {
      *validNorm = true;
      n->set(0, 0, (p.z() < 0) ? -1 : 1);
    }
    return 0.;
  }
  G4double vz = v.z();
  G4double tmax = (vz == 0) ? DBL_MAX : (std::copysign(fDz,vz) - p.z())/vz;
  G4int iside = (vz < 0) ? -4 : -2; // little trick: (-4+3)=-1, (-2+3)=+1
 
  // Y intersections
  //
  G4double cos0 = fPlanes[0].b*v.y() + fPlanes[0].c*v.z();
  if (cos0 > 0)
  {
    G4double dis0 = fPlanes[0].b*p.y() + fPlanes[0].c*p.z() + fPlanes[0].d;
    if (dis0 >= -halfCarTolerance)
    {
      if (calcNorm)
      {
        *validNorm = true;
        n->set(0, fPlanes[0].b, fPlanes[0].c);
      }
      return 0.;
    }
    G4double tmp = -dis0/cos0;
    if (tmax > tmp) { tmax = tmp; iside = 0; }
  }
 
  G4double cos1 = -cos0;
  if (cos1 > 0)
  {
    G4double dis1 = fPlanes[1].b*p.y() + fPlanes[1].c*p.z() + fPlanes[1].d;
    if (dis1 >= -halfCarTolerance)
    {
      if (calcNorm)
      {
        *validNorm = true;
        n->set(0, fPlanes[1].b, fPlanes[1].c);
      }
      return 0.;
    }
    G4double tmp = -dis1/cos1;
    if (tmax > tmp) { tmax = tmp; iside = 1; }
  }
 
  // X intersections
  //
  G4double cos2 = fPlanes[2].a*v.x() + fPlanes[2].b*v.y() + fPlanes[2].c*v.z();
  if (cos2 > 0)
  {
    G4double dis2 = fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z()+fPlanes[2].d;
    if (dis2 >= -halfCarTolerance)
    {
      if (calcNorm)
      {
         *validNorm = true;
         n->set(fPlanes[2].a, fPlanes[2].b, fPlanes[2].c);
      }
      return 0.;
    }
    G4double tmp = -dis2/cos2;
    if (tmax > tmp) { tmax = tmp; iside = 2; }
  }
 
  G4double cos3 = -cos2;
  if (cos3 > 0)
  {
    G4double dis3 = fPlanes[3].a*p.x()+fPlanes[3].b*p.y()
                  + fPlanes[3].c*p.z()+fPlanes[3].d;
    if (dis3 >= -halfCarTolerance)
    {
      if (calcNorm)
      {
         *validNorm = true;
         n->set(fPlanes[3].a, fPlanes[3].b, fPlanes[3].c);
      }
      return 0.;
    }
    G4double tmp = -dis3/cos3;
    if (tmax > tmp) { tmax = tmp; iside = 3; }
  }
 
  // Set normal, if required, and return distance
  //
  if (calcNorm)
  {
    *validNorm = true;
    (iside < 0) ? (n->set(0, 0, iside + 3)) // (-4+3)=-1, (-2+3)=+1
                : (n->set(fPlanes[iside].a, fPlanes[iside].b, fPlanes[iside].c));
  }
  return tmax;
}

◆ GetAlpha()

G4double G4Para::GetAlpha ( ) const

inline

◆ GetCubicVolume()

G4double G4Para::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units.

Reimplemented from G4VSolid.

Definition at line 860 of file G4Para.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&paraMutex);
    fCubicVolume = 8*fDx*fDy*fDz;
    l.unlock();
  }
  return fCubicVolume;
}

◆ GetEntityType()

G4GeometryType G4Para::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4Para" of the solid.

Implements G4VSolid.

Definition at line 768 of file G4Para.cc.

{
  return {"G4Para"};
}

◆ GetPhi()

G4double G4Para::GetPhi ( ) const

inline

◆ GetPointOnSurface()

G4ThreeVector G4Para::GetPointOnSurface ( ) const

overridevirtual

Returns a random point located and uniformly distributed on the surface of the solid.

Reimplemented from G4VSolid.

Definition at line 824 of file G4Para.cc.

{
  G4double sxy = fDx*fDy;
  G4double sxz = fDx*fDz*std::sqrt(1. + sqr(fTthetaSphi));
  G4double syz = fDy*fDz*std::sqrt(1. + sqr(fTalpha) + sqr(fTalpha*fTthetaSphi - fTthetaCphi));
 
  G4double select = (sxy + sxz + syz)*G4QuickRand();
  G4double u = 2.*G4QuickRand() - 1.;
  G4double v = 2.*G4QuickRand() - 1.;
 
  G4double x, y, z;
  if (select < sxy)
  {
    x = u*fDx;
    y = v*fDy;
    z = (select < 0.5*sxy) ? -fDz : fDz;
  }
  else if (select < sxy + sxz)
  {
    x = u*fDx;
    y = (select < sxy + 0.5*sxz) ? -fDy : fDy;
    z = v*fDz;
  }
  else
  {
    x = (select < sxy + sxz + 0.5*syz) ? -fDx : fDx;
    y = u*fDy;
    z = v*fDz;
  }
  return { x + y*fTalpha + z*fTthetaCphi, y + z*fTthetaSphi, z };
}

◆ GetSurfaceArea()

G4double G4Para::GetSurfaceArea ( )

overridevirtual

Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.

Reimplemented from G4VSolid.

Definition at line 875 of file G4Para.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&paraMutex);
    G4double sxy = fDx*fDy;
    G4double sxz = fDx*fDz*std::sqrt(1. + sqr(fTthetaSphi));
    G4double syz = fDy*fDz*std::sqrt(1. + sqr(fTalpha) + sqr(fTalpha*fTthetaSphi - fTthetaCphi));
    fSurfaceArea = 8*(sxy+sxz+syz);
    l.unlock();
  }
  return fSurfaceArea;
}

◆ GetSymAxis()

G4ThreeVector G4Para::GetSymAxis ( ) const

inline

Referenced by G4tgbVolume::BuildSolidForDivision(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Para_dimensionsWrite(), and G4GDMLWriteSolids::ParaWrite().

◆ GetTanAlpha()

G4double G4Para::GetTanAlpha ( ) const

inline

Referenced by BoundingLimits(), G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Para_dimensionsWrite(), and G4GDMLWriteSolids::ParaWrite().

◆ GetTheta()

G4double G4Para::GetTheta ( ) const

inline

◆ GetXHalfLength()

G4double G4Para::GetXHalfLength ( ) const

inline

Referenced by BoundingLimits(), G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Para_dimensionsWrite(), and G4GDMLWriteSolids::ParaWrite().

◆ GetYHalfLength()

G4double G4Para::GetYHalfLength ( ) const

inline

Referenced by BoundingLimits(), G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Para_dimensionsWrite(), and G4GDMLWriteSolids::ParaWrite().

◆ GetZHalfLength()

G4double G4Para::GetZHalfLength ( ) const

inline

Accessors. Obtain (re)computed values of the original parameters.

Referenced by BoundingLimits(), G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Para_dimensionsWrite(), and G4GDMLWriteSolids::ParaWrite().

◆ Inside()

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

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.

Implements G4VSolid.

Definition at line 377 of file G4Para.cc.

{
  G4double xx = fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z();
  G4double dx = std::abs(xx) + fPlanes[2].d;
 
  G4double yy = fPlanes[0].b*p.y()+fPlanes[0].c*p.z();
  G4double dy = std::abs(yy) + fPlanes[0].d;
  G4double dxy = std::max(dx,dy);
 
  G4double dz = std::abs(p.z())-fDz;
  G4double dist = std::max(dxy,dz);
 
  if (dist > halfCarTolerance) { return kOutside; }
 
  return (dist > -halfCarTolerance) ? kSurface : kInside;
}

Referenced by DistanceToOut().

◆ IsFaceted()

G4bool G4Para::IsFaceted ( ) const

overridevirtual

Returns true as the solid has only planar faces.

Reimplemented from G4VSolid.

Definition at line 777 of file G4Para.cc.

{
  return true;
}

◆ operator=()

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

Definition at line 155 of file G4Para.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4CSGSolid::operator=(rhs);
 
   // Copy data
   //
   halfCarTolerance = rhs.halfCarTolerance;
   fDx = rhs.fDx;
   fDy = rhs.fDy;
   fDz = rhs.fDz;
   fTalpha = rhs.fTalpha;
   fTthetaCphi = rhs.fTthetaCphi;
   fTthetaSphi = rhs.fTthetaSphi;
   for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs.fPlanes[i]; }
 
   return *this;
}

◆ SetAllParameters()

void G4Para::SetAllParameters	(	G4double	pDx,
		G4double	pDy,
		G4double	pDz,
		G4double	pAlpha,
		G4double	pTheta,
		G4double	pPhi )

Sets all parameters, as for constructor.

Definition at line 183 of file G4Para.cc.

{
  // Reset data of the base class
  fCubicVolume = 0;
  fSurfaceArea = 0;
  fRebuildPolyhedron = true;
 
  // Set parameters
  fDx = pDx;
  fDy = pDy;
  fDz = pDz;
  fTalpha = std::tan(pAlpha);
  fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
  fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
 
  CheckParameters();
  MakePlanes();
}

Referenced by G4ParameterisationParaX::ComputeDimensions(), G4ParameterisationParaY::ComputeDimensions(), G4ParameterisationParaZ::ComputeDimensions(), G4Para(), and G4Para().

◆ SetAlpha()

void G4Para::SetAlpha ( G4double alpha )

inline

◆ SetTanAlpha()

void G4Para::SetTanAlpha ( G4double val )

inline

◆ SetThetaAndPhi()

void G4Para::SetThetaAndPhi	(	G4double	pTheta,
		G4double	pPhi )

inline

◆ SetXHalfLength()

void G4Para::SetXHalfLength ( G4double val )

inline

Modifiers.

◆ SetYHalfLength()

void G4Para::SetYHalfLength ( G4double val )

inline

◆ SetZHalfLength()

void G4Para::SetZHalfLength ( G4double val )

inline

◆ StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Reimplemented from G4CSGSolid.

Definition at line 795 of file G4Para.cc.

{
  G4double alpha = std::atan(fTalpha);
  G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi +
                                       fTthetaSphi*fTthetaSphi));
  G4double phi   = std::atan2(fTthetaSphi,fTthetaCphi);
 
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4Para\n"
     << " Parameters:\n"
     << "    half length X: " << fDx/mm << " mm\n"
     << "    half length Y: " << fDy/mm << " mm\n"
     << "    half length Z: " << fDz/mm << " mm\n"
     << "    alpha: " << alpha/degree << "degrees\n"
     << "    theta: " << theta/degree << "degrees\n"
     << "    phi: " << phi/degree << "degrees\n"
     << "-----------------------------------------------------------\n";
  os.precision(oldprc);
 
  return os;
}

◆ SurfaceNormal()

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

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.

Parameters

[in] p The point at offset p.

Returns: The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 398 of file G4Para.cc.

{
  G4int nsurf = 0; // number of surfaces where p is placed
 
  // Check Z faces
  //
  G4double nz = 0;
  G4double dz = std::abs(p.z()) - fDz;
  if (std::abs(dz) <= halfCarTolerance)
  {
    nz = (p.z() < 0) ? -1 : 1;
    ++nsurf;
  }
 
  // Check Y faces
  //
  G4double ny = 0;
  G4double yy = fPlanes[0].b*p.y()+fPlanes[0].c*p.z();
  if (std::abs(fPlanes[0].d + yy) <= halfCarTolerance)
  {
    ny  = fPlanes[0].b;
    nz += fPlanes[0].c;
    ++nsurf;
  }
  else if (std::abs(fPlanes[1].d - yy) <= halfCarTolerance)
  {
    ny  = fPlanes[1].b;
    nz += fPlanes[1].c;
    ++nsurf;
  }
 
  // Check X faces
  //
  G4double nx = 0;
  G4double xx = fPlanes[2].a*p.x()+fPlanes[2].b*p.y()+fPlanes[2].c*p.z();
  if (std::abs(fPlanes[2].d + xx) <= halfCarTolerance)
  {
    nx  = fPlanes[2].a;
    ny += fPlanes[2].b;
    nz += fPlanes[2].c;
    ++nsurf;
  }
  else if (std::abs(fPlanes[3].d - xx) <= halfCarTolerance)
  {
    nx  = fPlanes[3].a;
    ny += fPlanes[3].b;
    nz += fPlanes[3].c;
    ++nsurf;
  }
 
  // Return normal
  //
  if (nsurf == 1)
  {
    return {nx,ny,nz};
  }
  if (nsurf != 0)
  {
    return G4ThreeVector(nx,ny,nz).unit(); // edge or corner
  }
 
  // Point is not on the surface
  //
#ifdef G4CSGDEBUG
  std::ostringstream message;
  G4int 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("G4Para::SurfaceNormal(p)", "GeomSolids1002",
              JustWarning, message );
  DumpInfo();
#endif
 
  return ApproxSurfaceNormal(p);
}

Member Data Documentation

◆ a

G4double G4Para::a

Definition at line 269 of file G4Para.hh.

Referenced by DistanceToOut(), and G4Para().

◆ b

G4double G4Para::b

Definition at line 269 of file G4Para.hh.

Referenced by DistanceToOut().

◆ c

G4double G4Para::c

Definition at line 269 of file G4Para.hh.

Referenced by DistanceToOut().

◆ d

G4double G4Para::d

Definition at line 269 of file G4Para.hh.

Referenced by SurfaceNormal().

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Para() [1/4]

◆ G4Para() [2/4]

◆ ~G4Para()

◆ G4Para() [3/4]

◆ G4Para() [4/4]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateExtent()

◆ Clone()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetAlpha()

◆ GetCubicVolume()

◆ GetEntityType()

◆ GetPhi()

◆ GetPointOnSurface()

◆ GetSurfaceArea()

◆ GetSymAxis()

◆ GetTanAlpha()

◆ GetTheta()

◆ GetXHalfLength()

◆ GetYHalfLength()

◆ GetZHalfLength()

◆ Inside()

◆ IsFaceted()

◆ operator=()

◆ SetAllParameters()

◆ SetAlpha()

◆ SetTanAlpha()

◆ SetThetaAndPhi()

◆ SetXHalfLength()

◆ SetYHalfLength()

◆ SetZHalfLength()

◆ StreamInfo()

◆ SurfaceNormal()

Member Data Documentation

◆ a

◆ b

◆ c

◆ d