G4Polycone Class Reference

G4Polycone represents a composed closed shape (PCON) made of cones and cylinders, along the Z axis with increasing Z, with or without cut in Phi. More...

#include <G4Polycone.hh>

Inheritance diagram for G4Polycone:

Public Member Functions
	G4Polycone (const G4String &name, G4double phiStart, G4double phiTotal, G4int numZPlanes, const G4double zPlane[], const G4double rInner[], const G4double rOuter[])
	G4Polycone (const G4String &name, G4double phiStart, G4double phiTotal, G4int numRZ, const G4double r[], const G4double z[])
	~G4Polycone () override
G4double	GetStartPhi () const
G4double	GetEndPhi () const
G4double	GetSinStartPhi () const
G4double	GetCosStartPhi () const
G4double	GetSinEndPhi () const
G4double	GetCosEndPhi () const
G4bool	IsOpen () const
G4int	GetNumRZCorner () const
G4PolyconeSideRZ	GetCorner (G4int index) const
G4PolyconeHistorical *	GetOriginalParameters () const
void	SetOriginalParameters (G4PolyconeHistorical *pars)
EInside	Inside (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const 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
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4ThreeVector	GetPointOnSurface () const override
void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep) override
G4GeometryType	GetEntityType () const override
G4VSolid *	Clone () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4Polyhedron *	CreatePolyhedron () const override
G4bool	Reset ()
	G4Polycone (__void__ &)
	G4Polycone (const G4Polycone &source)
G4Polycone &	operator= (const G4Polycone &source)
Public Member Functions inherited from G4VCSGfaceted
	G4VCSGfaceted (const G4String &name)
	~G4VCSGfaceted () override
	G4VCSGfaceted (const G4VCSGfaceted &source)
G4VCSGfaceted &	operator= (const G4VCSGfaceted &source)
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
std::ostream &	StreamInfo (std::ostream &os) const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4Polyhedron *	GetPolyhedron () const override
G4int	GetCubVolStatistics () const
G4double	GetCubVolEpsilon () const
void	SetCubVolStatistics (G4int st)
void	SetCubVolEpsilon (G4double ep)
G4int	GetAreaStatistics () const
G4double	GetAreaAccuracy () const
void	SetAreaStatistics (G4int st)
void	SetAreaAccuracy (G4double ep)
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
	G4VCSGfaceted (__void__ &)
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
virtual G4bool	IsFaceted () const
void	DumpInfo () 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 G4VCSGfaceted
virtual G4double	DistanceTo (const G4ThreeVector &p, const G4bool outgoing) const
G4ThreeVector	GetPointOnSurfaceGeneric () const
void	CopyStuff (const G4VCSGfaceted &source)
void	DeleteStuff ()
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 G4VCSGfaceted
G4int	numFace = 0
G4VCSGface **	faces = nullptr
G4double	fCubicVolume = 0.0
G4double	fSurfaceArea = 0.0
G4bool	fRebuildPolyhedron = false
G4Polyhedron *	fpPolyhedron = nullptr
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

G4Polycone represents a composed closed shape (PCON) made of cones and cylinders, along the Z axis with increasing Z, with or without cut in Phi.

Definition at line 81 of file G4Polycone.hh.

Constructor & Destructor Documentation

G4Polycone() [1/4]

G4Polycone::G4Polycone	(	const G4String &	name,
		G4double	phiStart,
		G4double	phiTotal,
		G4int	numZPlanes,
		const G4double	zPlane[],
		const G4double	rInner[],
		const G4double	rOuter[] )

Constructs a polycone shape, given its parameters.

Parameters

[in]	name	The solid name.
[in]	phiStart	Initial Phi starting angle.
[in]	phiTotal	Total Phi angle.
[in]	numZPlanes	Number of Z planes.
[in]	zPlane	Position of Z planes, with Z in increasing order.
[in]	rInner	Tangent distance to inner surface.
[in]	rOuter	Tangent distance to outer surface.

Definition at line 59 of file G4Polycone.cc.

  : G4VCSGfaceted( name )
{
  //
  // Some historical ugliness
  //
  original_parameters = new G4PolyconeHistorical();
 
  original_parameters->Start_angle = phiStart;
  original_parameters->Opening_angle = phiTotal;
  original_parameters->Num_z_planes = numZPlanes;
  original_parameters->Z_values = new G4double[numZPlanes];
  original_parameters->Rmin = new G4double[numZPlanes];
  original_parameters->Rmax = new G4double[numZPlanes];
 
  for (G4int i=0; i<numZPlanes; ++i)
  {
    if(rInner[i]>rOuter[i])
    {
      DumpInfo();
      std::ostringstream message;
      message << "Cannot create a Polycone with rInner > rOuter for the same Z"
              << G4endl
              << "        rInner > rOuter for the same Z !" << G4endl
              << "        rMin[" << i << "] = " << rInner[i]
              << " -- rMax[" << i << "] = " << rOuter[i];
      G4Exception("G4Polycone::G4Polycone()", "GeomSolids0002",
                  FatalErrorInArgument, message);
    }
    if (( i < numZPlanes-1) && ( zPlane[i] == zPlane[i+1] ))
    {
      if( (rInner[i]   > rOuter[i+1])
        ||(rInner[i+1] > rOuter[i])   )
      {
        DumpInfo();
        std::ostringstream message;
        message << "Cannot create a Polycone with no contiguous segments."
                << G4endl
                << "        Segments are not contiguous !" << G4endl
                << "        rMin[" << i << "] = " << rInner[i]
                << " -- rMax[" << i+1 << "] = " << rOuter[i+1] << G4endl
                << "        rMin[" << i+1 << "] = " << rInner[i+1]
                << " -- rMax[" << i << "] = " << rOuter[i];
        G4Exception("G4Polycone::G4Polycone()", "GeomSolids0002",
                    FatalErrorInArgument, message);
      }
    }
    original_parameters->Z_values[i] = zPlane[i];
    original_parameters->Rmin[i] = rInner[i];
    original_parameters->Rmax[i] = rOuter[i];
  }
 
  //
  // Build RZ polygon using special PCON/PGON GEANT3 constructor
  //
  auto rz = new G4ReduciblePolygon( rInner, rOuter, zPlane, numZPlanes );
 
  //
  // Do the real work
  //
  Create( phiStart, phiTotal, rz );
 
  delete rz;
}

Referenced by Clone(), G4Polycone(), operator=(), and SetOriginalParameters().

G4Polycone() [2/4]

G4Polycone::G4Polycone	(	const G4String &	name,
		G4double	phiStart,
		G4double	phiTotal,
		G4int	numRZ,
		const G4double	r[],
		const G4double	z[] )

Alternative constructor of a polycone shape, given corners coordinates.

Parameters

[in]	name	The solid name.
[in]	phiStart	Initial Phi starting angle.
[in]	phiTotal	Total Phi angle.
[in]	numRZ	Number of corners in r,Z space.
[in]	r	r coordinates of corners.
[in]	z	Z coordinates of corners.

Definition at line 132 of file G4Polycone.cc.

  : G4VCSGfaceted( name )
{
 
  auto rz = new G4ReduciblePolygon( r, z, numRZ );
 
  Create( phiStart, phiTotal, rz );
 
  // Set original_parameters struct for consistency
  //
 
  G4bool convertible = SetOriginalParameters(rz);
 
  if(!convertible)
  {
    std::ostringstream message;
    message << "Polycone " << GetName() << "cannot be converted" << G4endl
            << "to Polycone with (Rmin,Rmaz,Z) parameters!";
    G4Exception("G4Polycone::G4Polycone()", "GeomSolids0002",
                FatalException, message, "Use G4GenericPolycone instead!");
  }
  else
  {
    G4cout << "INFO: Converting polycone " << GetName() << G4endl
           << "to optimized polycone with (Rmin,Rmaz,Z) parameters !"
           << G4endl;
  }
  delete rz;
}

~G4Polycone()

G4Polycone::~G4Polycone ( )

override

Destructor.

Definition at line 344 of file G4Polycone.cc.

{
  delete [] corners;
  delete original_parameters;
  delete enclosingCylinder;
  delete fElements;
  delete fpPolyhedron;
  corners = nullptr;
  original_parameters = nullptr;
  enclosingCylinder = nullptr;
  fElements = nullptr;
  fpPolyhedron = nullptr;
}

G4Polycone() [3/4]

G4Polycone::G4Polycone

(

__void__ &

a

)

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

Definition at line 335 of file G4Polycone.cc.

  : G4VCSGfaceted(a), startPhi(0.),  endPhi(0.), numCorner(0)
{
}

G4Polycone() [4/4]

G4Polycone::G4Polycone

(

const G4Polycone &

source

)

Copy constructor and assignment operator.

Definition at line 360 of file G4Polycone.cc.

  : G4VCSGfaceted( source )
{
  CopyStuff( source );
}

Member Function Documentation

BoundingLimits()

void G4Polycone::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 511 of file G4Polycone.cc.

{
  G4double rmin = kInfinity, rmax = -kInfinity;
  G4double zmin = kInfinity, zmax = -kInfinity;
 
  for (G4int i=0; i<GetNumRZCorner(); ++i)
  {
    G4PolyconeSideRZ corner = GetCorner(i);
    if (corner.r < rmin) { rmin = corner.r; }
    if (corner.r > rmax) { rmax = corner.r; }
    if (corner.z < zmin) { zmin = corner.z; }
    if (corner.z > zmax) { zmax = corner.z; }
  }
 
  if (IsOpen())
  {
    G4TwoVector vmin,vmax;
    G4GeomTools::DiskExtent(rmin,rmax,
                            GetSinStartPhi(),GetCosStartPhi(),
                            GetSinEndPhi(),GetCosEndPhi(),
                            vmin,vmax);
    pMin.set(vmin.x(),vmin.y(),zmin);
    pMax.set(vmax.x(),vmax.y(),zmax);
  }
  else
  {
    pMin.set(-rmax,-rmax, zmin);
    pMax.set( rmax, rmax, zmax);
  }
 
  // 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("G4Polycone::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent().

CalculateExtent()

G4bool G4Polycone::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 559 of file G4Polycone.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;
  }
 
  // To find the extent, RZ contour of the polycone is subdivided
  // in triangles. The extent is calculated as cumulative extent of
  // all sub-polycones formed by rotation of triangles around Z
  //
  G4TwoVectorList contourRZ;
  G4TwoVectorList triangles;
  std::vector<G4int> iout;
  G4double eminlim = pVoxelLimit.GetMinExtent(pAxis);
  G4double emaxlim = pVoxelLimit.GetMaxExtent(pAxis);
 
  // get RZ contour, ensure anticlockwise order of corners
  for (G4int i=0; i<GetNumRZCorner(); ++i)
  {
    G4PolyconeSideRZ corner = GetCorner(i);
    contourRZ.emplace_back(corner.r,corner.z);
  }
  G4GeomTools::RemoveRedundantVertices(contourRZ,iout,2*kCarTolerance);
  G4double area = G4GeomTools::PolygonArea(contourRZ);
  if (area < 0.) { std::reverse(contourRZ.begin(),contourRZ.end()); }
 
  // triangulate RZ countour
  if (!G4GeomTools::TriangulatePolygon(contourRZ,triangles))
  {
    std::ostringstream message;
    message << "Triangulation of RZ contour has failed for solid: "
            << GetName() << " !"
            << "\nExtent has been calculated using boundary box";
    G4Exception("G4Polycone::CalculateExtent()",
                "GeomMgt1002", JustWarning, message);
    return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
  }
 
  // set trigonometric values
  const G4int NSTEPS = 24;            // number of steps for whole circle
  G4double astep  = twopi/NSTEPS;     // max angle for one step
 
  G4double sphi   = GetStartPhi();
  G4double ephi   = GetEndPhi();
  G4double dphi   = IsOpen() ? ephi-sphi : twopi;
  G4int    ksteps = (dphi <= astep) ? 1 : (G4int)((dphi-deg)/astep) + 1;
  G4double ang    = dphi/ksteps;
 
  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 sinStart = GetSinStartPhi();
  G4double cosStart = GetCosStartPhi();
  G4double sinEnd   = GetSinEndPhi();
  G4double cosEnd   = GetCosEndPhi();
 
  // define vectors and arrays
  std::vector<const G4ThreeVectorList *> polygons;
  polygons.resize(ksteps+2);
  G4ThreeVectorList pols[NSTEPS+2];
  for (G4int k=0; k<ksteps+2; ++k)
  {
    pols[k].resize(6);
  }
  for (G4int k=0; k<ksteps+2; ++k)
  {
    polygons[k] = &pols[k];
  }
  G4double r0[6],z0[6]; // contour with original edges of triangle
  G4double r1[6];       // shifted radii of external edges of triangle
 
  // main loop along triangles
  pMin = kInfinity;
  pMax =-kInfinity;
  G4int ntria = (G4int)triangles.size()/3;
  for (G4int i=0; i<ntria; ++i)
  {
    G4int i3 = i*3;
    for (G4int k=0; k<3; ++k)
    {
      G4int e0 = i3+k, e1 = (k<2) ? e0+1 : i3;
      G4int k2 = k*2;
      // set contour with original edges of triangle
      r0[k2+0] = triangles[e0].x(); z0[k2+0] = triangles[e0].y();
      r0[k2+1] = triangles[e1].x(); z0[k2+1] = triangles[e1].y();
      // set shifted radii
      r1[k2+0] = r0[k2+0];
      r1[k2+1] = r0[k2+1];
      if (z0[k2+1] - z0[k2+0] <= 0) { continue; }
      r1[k2+0] /= cosHalf;
      r1[k2+1] /= cosHalf;
    }
 
    // rotate countour, set sequence of 6-sided polygons
    G4double sinCur = sinStart*cosHalf + cosStart*sinHalf;
    G4double cosCur = cosStart*cosHalf - sinStart*sinHalf;
    for (G4int j=0; j<6; ++j)
    {
      pols[0][j].set(r0[j]*cosStart,r0[j]*sinStart,z0[j]);
    }
    for (G4int k=1; k<ksteps+1; ++k)
    {
      for (G4int j=0; j<6; ++j)
      {
        pols[k][j].set(r1[j]*cosCur,r1[j]*sinCur,z0[j]);
      }
      G4double sinTmp = sinCur;
      sinCur = sinCur*cosStep + cosCur*sinStep;
      cosCur = cosCur*cosStep - sinTmp*sinStep;
    }
    for (G4int j=0; j<6; ++j)
    {
      pols[ksteps+1][j].set(r0[j]*cosEnd,r0[j]*sinEnd,z0[j]);
    }
 
    // set sub-envelope and adjust extent
    G4double emin,emax;
    G4BoundingEnvelope benv(polygons);
    if (!benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,emin,emax))
    {
      continue;
    }
    if (emin < pMin) { pMin = emin; }
    if (emax > pMax) { pMax = emax; }
    if (eminlim > pMin && emaxlim < pMax) { return true; } // max possible extent
  }
  return (pMin < pMax);
}

Clone()

G4VSolid * G4Polycone::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 722 of file G4Polycone.cc.

{
  return new G4Polycone(*this);
}

ComputeDimensions()

void G4Polycone::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 706 of file G4Polycone.cc.

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

CreatePolyhedron()

G4Polyhedron * G4Polycone::CreatePolyhedron ( ) const

overridevirtual

Returns a pointer to a generated polyhedron used for visualisation.

Implements G4VCSGfaceted.

Definition at line 973 of file G4Polycone.cc.

{
  std::vector<G4TwoVector> rz(numCorner);
  for (G4int i = 0; i < numCorner; ++i)
  {
    rz[i].set(corners[i].r, corners[i].z);
  }
  return new G4PolyhedronPcon(startPhi, endPhi - startPhi, rz);
}

DistanceToIn() [1/2]

G4double G4Polycone::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 504 of file G4Polycone.cc.

{
  return G4VCSGfaceted::DistanceToIn(p);
}

DistanceToIn() [2/2]

G4double G4Polycone::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 488 of file G4Polycone.cc.

{
  //
  // Quick test
  //
  if (enclosingCylinder->ShouldMiss(p,v)) { return kInfinity; }
 
  //
  // Long answer
  //
  return G4VCSGfaceted::DistanceToIn( p, v );
}

GetCorner()

G4PolyconeSideRZ G4Polycone::GetCorner ( G4int index ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), GetCubicVolume(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), and GetSurfaceArea().

GetCosEndPhi()

G4double G4Polycone::GetCosEndPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetCosStartPhi()

G4double G4Polycone::GetCosStartPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetCubicVolume()

G4double G4Polycone::GetCubicVolume ( )

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 780 of file G4Polycone.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&polyconeMutex);
    G4double total = 0.;
    G4int nrz = GetNumRZCorner();
    G4PolyconeSideRZ a = GetCorner(nrz - 1);
    for (G4int i=0; i<nrz; ++i)
    {
      G4PolyconeSideRZ b = GetCorner(i);
      total += (b.r*b.r + b.r*a.r + a.r*a.r)*(b.z - a.z);
      a = b;
    }
    fCubicVolume = std::abs(total)*(GetEndPhi() - GetStartPhi())/6.;
    l.unlock();
  }
  return fCubicVolume;
}

GetEndPhi()

G4double G4Polycone::GetEndPhi ( ) const

inline

Referenced by G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), GetCubicVolume(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), and GetSurfaceArea().

GetEntityType()

G4GeometryType G4Polycone::GetEntityType ( ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 715 of file G4Polycone.cc.

{
  return {"G4Polycone"};
}

GetNumRZCorner()

G4int G4Polycone::GetNumRZCorner ( ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), GetCubicVolume(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), and GetSurfaceArea().

GetOriginalParameters()

G4PolyconeHistorical * G4Polycone::GetOriginalParameters ( ) const

inline

Gets and sets the original parameters of the solid.

Referenced by G4tgbVolume::BuildSolidForDivision(), G4GDMLWriteParamvol::Polycone_dimensionsWrite(), and G4GDMLWriteSolids::PolyconeWrite().

GetPointOnSurface()

G4ThreeVector G4Polycone::GetPointOnSurface ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 908 of file G4Polycone.cc.

{
  // Set surface elements
  if (fElements == nullptr)
  {
    G4AutoLock l(&surface_elementsMutex);
    SetSurfaceElements();
    l.unlock();
  }
 
  // Select surface element
  G4Polycone::surface_element selem;
  selem = fElements->back();
  G4double select = selem.area*G4QuickRand();
  auto it = std::lower_bound(fElements->begin(), fElements->end(), select,
                             [](const G4Polycone::surface_element& x, G4double val)
                             -> G4bool { return x.area < val; });
 
  // Generate random point
  G4double r = 0, z = 0, phi = 0;
  G4double u = G4QuickRand();
  G4double v = G4QuickRand();
  G4int i0 = (*it).i0;
  G4int i1 = (*it).i1;
  G4int i2 = (*it).i2;
  if (i2 < 0) // lateral surface
  {
    G4PolyconeSideRZ p0 = GetCorner(i0);
    G4PolyconeSideRZ p1 = GetCorner(i1);
    if (p1.r < p0.r)
    {
      p0 = GetCorner(i1);
      p1 = GetCorner(i0);
    }
    if (p1.r - p0.r < kCarTolerance) // cylindrical surface
    {
      r = (p1.r - p0.r)*u + p0.r;
      z = (p1.z - p0.z)*u + p0.z;
    }
    else // conical surface
    {
      r = std::sqrt(p1.r*p1.r*u + p0.r*p0.r*(1. - u));
      z = p0.z + (p1.z - p0.z)*(r - p0.r)/(p1.r - p0.r);
    }
    phi = (GetEndPhi() - GetStartPhi())*v + GetStartPhi();
  }
  else // phi cut
  {
    G4int nrz = GetNumRZCorner();
    phi = (i0 < nrz) ? GetStartPhi() : GetEndPhi();
    if (i0 >= nrz) { i0 -= nrz; }
    G4PolyconeSideRZ p0 = GetCorner(i0);
    G4PolyconeSideRZ p1 = GetCorner(i1);
    G4PolyconeSideRZ p2 = GetCorner(i2);
    if (u + v > 1.) { u = 1. - u; v = 1. - v; }
    r = (p1.r - p0.r)*u +  (p2.r - p0.r)*v + p0.r;
    z = (p1.z - p0.z)*u +  (p2.z - p0.z)*v + p0.z;
  }
  return { r*std::cos(phi), r*std::sin(phi), z };
}

GetSinEndPhi()

G4double G4Polycone::GetSinEndPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetSinStartPhi()

G4double G4Polycone::GetSinStartPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetStartPhi()

G4double G4Polycone::GetStartPhi ( ) const

inline

Accessors.

Referenced by G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), GetCubicVolume(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), and GetSurfaceArea().

GetSurfaceArea()

G4double G4Polycone::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 804 of file G4Polycone.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&polyconeMutex);
    // phi cut area
    G4int nrz = GetNumRZCorner();
    G4double scut = 0.;
    if (IsOpen())
    {
      G4PolyconeSideRZ a = GetCorner(nrz - 1);
      for (G4int i=0; i<nrz; ++i)
      {
        G4PolyconeSideRZ b = GetCorner(i);
        scut += a.r*b.z - a.z*b.r;
        a = b;
      }
      scut = std::abs(scut);
    }
    // lateral surface area
    G4double slat = 0;
    G4PolyconeSideRZ a = GetCorner(nrz - 1);
    for (G4int i=0; i<nrz; ++i)
    {
      G4PolyconeSideRZ b = GetCorner(i);
      G4double h = std::sqrt((b.r - a.r)*(b.r - a.r) + (b.z - a.z)*(b.z - a.z));
      slat += (b.r + a.r)*h;
      a = b;
    }
    slat *= (GetEndPhi() - GetStartPhi())/2.;
    fSurfaceArea = scut + slat;
    l.unlock();
  }
  return fSurfaceArea;
}

Inside()

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

overridevirtual

Concrete implementations of the expected query interfaces for solids, as defined in G4VSolid. Remaining functions are concretely defined in the base class G4VCSGfaceted.

Implements G4VSolid.

Definition at line 470 of file G4Polycone.cc.

{
  //
  // Quick test
  //
  if (enclosingCylinder->MustBeOutside(p)) { return kOutside; }
 
  //
  // Long answer
  //
  return G4VCSGfaceted::Inside(p);
}

IsOpen()

G4bool G4Polycone::IsOpen ( ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), and GetSurfaceArea().

operator=()

G4Polycone & G4Polycone::operator=

(

const G4Polycone &

source

)

Definition at line 368 of file G4Polycone.cc.

{
  if (this == &source) { return *this; }
 
  G4VCSGfaceted::operator=( source );
 
  delete [] corners;
  delete original_parameters;
 
  delete enclosingCylinder;
 
  CopyStuff( source );
 
  return *this;
}

Reset()

G4bool G4Polycone::Reset

(

)

Clears all parameters and rebuild the shape, for use in divisions.

Definition at line 438 of file G4Polycone.cc.

{
  //
  // Clear old setup
  //
  G4VCSGfaceted::DeleteStuff();
  delete [] corners;
  delete enclosingCylinder;
  delete fElements;
  corners = nullptr;
  fElements = nullptr;
  enclosingCylinder = nullptr;
 
  //
  // Rebuild polycone
  //
  auto rz = new G4ReduciblePolygon( original_parameters->Rmin,
                                    original_parameters->Rmax,
                                    original_parameters->Z_values,
                                    original_parameters->Num_z_planes );
  Create( original_parameters->Start_angle,
          original_parameters->Opening_angle, rz );
  delete rz;
 
  return false;
}

Referenced by G4ParameterisationPolyconePhi::ComputeDimensions(), G4ParameterisationPolyconeRho::ComputeDimensions(), and G4ParameterisationPolyconeZ::ComputeDimensions().

SetOriginalParameters()

void G4Polycone::SetOriginalParameters ( G4PolyconeHistorical * pars )

inline

Referenced by G4ParameterisationPolyconePhi::ComputeDimensions(), G4ParameterisationPolyconeRho::ComputeDimensions(), G4ParameterisationPolyconeZ::ComputeDimensions(), and G4Polycone().

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 730 of file G4Polycone.cc.

{
  G4long oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4Polycone\n"
     << " Parameters: \n"
     << "    starting phi angle : " << startPhi/degree << " degrees \n"
     << "    ending phi angle   : " << endPhi/degree << " degrees \n";
  G4int i=0;
 
    G4int numPlanes = original_parameters->Num_z_planes;
    os << "    number of Z planes: " << numPlanes << "\n"
       << "              Z values: \n";
    for (i=0; i<numPlanes; ++i)
    {
      os << "              Z plane " << i << ": "
         << original_parameters->Z_values[i] << "\n";
    }
    os << "              Tangent distances to inner surface (Rmin): \n";
    for (i=0; i<numPlanes; ++i)
    {
      os << "              Z plane " << i << ": "
         << original_parameters->Rmin[i] << "\n";
    }
    os << "              Tangent distances to outer surface (Rmax): \n";
    for (i=0; i<numPlanes; ++i)
    {
      os << "              Z plane " << i << ": "
         << original_parameters->Rmax[i] << "\n";
    }
 
  os << "    number of RZ points: " << numCorner << "\n"
     << "              RZ values (corners): \n";
     for (i=0; i<numCorner; ++i)
     {
       os << "                         "
          << corners[i].r << ", " << corners[i].z << "\n";
     }
  os << "-----------------------------------------------------------\n";
  os.precision(oldprc);
 
  return os;
}

---

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

• G4Polycone.hh
• G4Polycone.cc