G4GenericPolycone Class Reference

#include <G4GenericPolycone.hh>

Inheritance diagram for G4GenericPolycone:

Data Structures
struct	surface_element

Public Member Functions
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const
G4VSolid *	Clone () const
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
G4Polyhedron *	CreatePolyhedron () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const
G4double	DistanceToIn (const G4ThreeVector &p) const
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const
virtual G4double	DistanceToOut (const G4ThreeVector &p) const
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const
void	DumpInfo () const
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const
	G4GenericPolycone (__void__ &)
	G4GenericPolycone (const G4GenericPolycone &source)
	G4GenericPolycone (const G4String &name, G4double phiStart, G4double phiTotal, G4int numRZ, const G4double r[], const G4double z[])
G4double	GetAreaAccuracy () const
G4int	GetAreaStatistics () const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
G4PolyconeSideRZ	GetCorner (G4int index) const
G4double	GetCosEndPhi () const
G4double	GetCosStartPhi () const
G4double	GetCubicVolume ()
G4double	GetCubVolEpsilon () const
G4int	GetCubVolStatistics () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
G4double	GetEndPhi () const
G4GeometryType	GetEntityType () const
virtual G4VisExtent	GetExtent () const
G4String	GetName () const
G4int	GetNumRZCorner () const
G4ThreeVector	GetPointOnSurface () const
virtual G4Polyhedron *	GetPolyhedron () const
G4double	GetSinEndPhi () const
G4double	GetSinStartPhi () const
G4double	GetStartPhi () const
G4double	GetSurfaceArea ()
G4double	GetTolerance () const
EInside	Inside (const G4ThreeVector &p) const
G4bool	IsOpen () const
G4GenericPolycone &	operator= (const G4GenericPolycone &source)
G4bool	operator== (const G4VSolid &s) const
G4bool	Reset ()
void	SetAreaAccuracy (G4double ep)
void	SetAreaStatistics (G4int st)
void	SetCubVolEpsilon (G4double ep)
void	SetCubVolStatistics (G4int st)
void	SetName (const G4String &name)
std::ostream &	StreamInfo (std::ostream &os) const
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const
virtual	~G4GenericPolycone ()

Protected Member Functions
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const
void	CopyStuff (const G4GenericPolycone &source)
void	CopyStuff (const G4VCSGfaceted &source)
void	Create (G4double phiStart, G4double phiTotal, G4ReduciblePolygon *rz)
void	DeleteStuff ()
virtual G4double	DistanceTo (const G4ThreeVector &p, const G4bool outgoing) const
G4ThreeVector	GetPointOnSurfaceGeneric () const
void	SetSurfaceElements () const

Protected Attributes
G4PolyconeSideRZ *	corners = nullptr
G4EnclosingCylinder *	enclosingCylinder = nullptr
G4double	endPhi
G4VCSGface **	faces = nullptr
G4double	fCubicVolume = 0.0
std::vector< surface_element > *	fElements = nullptr
G4Polyhedron *	fpPolyhedron = nullptr
G4bool	fRebuildPolyhedron = false
G4double	fSurfaceArea = 0.0
G4double	kCarTolerance
G4int	numCorner
G4int	numFace = 0
G4bool	phiIsOpen = false
G4double	startPhi

Private Member Functions
void	ClipPolygonToSimpleLimits (G4ThreeVectorList &pPolygon, G4ThreeVectorList &outputPolygon, const G4VoxelLimits &pVoxelLimit) const

Private Attributes
G4double	fAreaAccuracy
G4double	fCubVolEpsilon
G4String	fshapeName
G4int	fStatistics

Detailed Description

Definition at line 65 of file G4GenericPolycone.hh.

Constructor & Destructor Documentation

G4GenericPolycone() [1/3]

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

Definition at line 59 of file G4GenericPolycone.cc.

  : G4VCSGfaceted( name )
{
 
  G4ReduciblePolygon *rz = new G4ReduciblePolygon( r, z, numRZ );
 
  Create( phiStart, phiTotal, rz );
 
  // Set original_parameters struct for consistency
  //
  //SetOriginalParameters(rz);
 
  delete rz;
}

References Create().

Referenced by Clone().

~G4GenericPolycone()

G4GenericPolycone::~G4GenericPolycone ( )

virtual

Definition at line 259 of file G4GenericPolycone.cc.

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

References corners, enclosingCylinder, fElements, and G4VCSGfaceted::fpPolyhedron.

G4GenericPolycone() [2/3]

G4GenericPolycone::G4GenericPolycone

(

__void__ &

a

)

Definition at line 252 of file G4GenericPolycone.cc.

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

G4GenericPolycone() [3/3]

G4GenericPolycone::G4GenericPolycone

(

const G4GenericPolycone &

source

)

Definition at line 273 of file G4GenericPolycone.cc.

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

References CopyStuff().

Member Function Documentation

BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 402 of file G4GenericPolycone.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("GenericG4Polycone::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

References G4GeomTools::DiskExtent(), G4VSolid::DumpInfo(), G4Exception(), GetCorner(), GetCosEndPhi(), GetCosStartPhi(), G4VSolid::GetName(), GetNumRZCorner(), GetSinEndPhi(), GetSinStartPhi(), IsOpen(), JustWarning, kInfinity, pMax, pMin, G4PolyconeSideRZ::r, CLHEP::Hep2Vector::x(), CLHEP::Hep2Vector::y(), and G4PolyconeSideRZ::z.

Referenced by CalculateExtent().

CalculateClippedPolygonExtent()

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

protectedinherited

Definition at line 489 of file G4VSolid.cc.

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

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

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

CalculateExtent()

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 453 of file G4GenericPolycone.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;
  }
 
  // 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;
  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.push_back(G4TwoVector(corner.r,corner.z));
  }
  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("G4GenericPolycone::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 = 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);
}

References G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), BoundingLimits(), G4BoundingEnvelope::CalculateExtent(), deg, e1, emax, G4Exception(), GetCorner(), GetCosEndPhi(), GetCosStartPhi(), GetEndPhi(), G4VoxelLimits::GetMaxExtent(), G4VoxelLimits::GetMinExtent(), G4VSolid::GetName(), GetNumRZCorner(), GetSinEndPhi(), GetSinStartPhi(), GetStartPhi(), IsOpen(), JustWarning, kInfinity, pMax, pMin, G4GeomTools::PolygonArea(), G4PolyconeSideRZ::r, G4GeomTools::TriangulatePolygon(), twopi, G4PolyconeSideRZ::z, and G4InuclParticleNames::z0.

ClipBetweenSections()

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

protectedinherited

Definition at line 444 of file G4VSolid.cc.

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

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

ClipCrossSection()

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

protectedinherited

Definition at line 414 of file G4VSolid.cc.

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

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

ClipPolygon()

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

protectedinherited

Definition at line 539 of file G4VSolid.cc.

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

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

Referenced by G4VSolid::CalculateClippedPolygonExtent().

ClipPolygonToSimpleLimits()

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

privateinherited

Definition at line 612 of file G4VSolid.cc.

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

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

Referenced by G4VSolid::ClipPolygon().

Clone()

G4VSolid * G4GenericPolycone::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 598 of file G4GenericPolycone.cc.

{
  return new G4GenericPolycone(*this);
}

References G4GenericPolycone().

ComputeDimensions()

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

virtualinherited

Reimplemented in G4TwistedTubs, G4VTwistedFaceted, G4ReflectedSolid, G4DisplacedSolid, G4IntersectionSolid, G4ScaledSolid, G4SubtractionSolid, G4UnionSolid, G4Box, G4Cons, G4Orb, G4Para, G4Sphere, G4Torus, G4Trap, G4Trd, G4Tubs, G4Ellipsoid, G4Hype, G4Polycone, G4Polyhedra, and G4Tet.

Definition at line 137 of file G4VSolid.cc.

{
    std::ostringstream message;
    message << "Illegal call to G4VSolid::ComputeDimensions()" << G4endl
            << "Method not overloaded by derived class !";
    G4Exception("G4VSolid::ComputeDimensions()", "GeomMgt0003",
                FatalException, message);
}

References FatalException, G4endl, and G4Exception().

Referenced by G4SmartVoxelHeader::BuildNodes(), G4PVParameterised::CheckOverlaps(), G4VPrimitiveScorer::ComputeSolid(), G4ScoreSplittingProcess::CreateTouchableForSubStep(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4LogicalVolume::GetMass(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4Navigator::SetupHierarchy(), G4ITNavigator1::SetupHierarchy(), and G4ITNavigator2::SetupHierarchy().

CopyStuff() [1/2]

void G4GenericPolycone::CopyStuff ( const G4GenericPolycone &  source )

protected

Definition at line 300 of file G4GenericPolycone.cc.

{
  //
  // Simple stuff
  //
  startPhi  = source.startPhi;
  endPhi    = source.endPhi;
  phiIsOpen = source.phiIsOpen;
  numCorner = source.numCorner;
 
  //
  // The corner array
  //
  corners = new G4PolyconeSideRZ[numCorner];
 
  G4PolyconeSideRZ  *corn = corners,
        *sourceCorn = source.corners;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    *corn = *sourceCorn;
  } while( ++sourceCorn, ++corn < corners+numCorner );
 
  //
  // Enclosing cylinder
  //
  enclosingCylinder = new G4EnclosingCylinder( *source.enclosingCylinder );
 
  //
  // Surface elements
  //
  delete fElements;
  fElements = nullptr;
 
  // Polyhedron
  //
  fRebuildPolyhedron = false;
  delete fpPolyhedron;
  fpPolyhedron = nullptr;
}

References corners, enclosingCylinder, endPhi, fElements, G4VCSGfaceted::fpPolyhedron, G4VCSGfaceted::fRebuildPolyhedron, numCorner, phiIsOpen, and startPhi.

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

CopyStuff() [2/2]

void G4VCSGfaceted::CopyStuff ( const G4VCSGfaceted &  source )

protectedinherited

Definition at line 125 of file G4VCSGfaceted.cc.

{
  numFace = source.numFace;
  if (numFace == 0) { return; }    // odd, but permissable?
  
  faces = new G4VCSGface*[numFace];
  
  G4VCSGface **face = faces,
       **sourceFace = source.faces;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    *face = (*sourceFace)->Clone();
  } while( ++sourceFace, ++face < faces+numFace );
  fCubicVolume = source.fCubicVolume;
  fSurfaceArea = source.fSurfaceArea;
  fRebuildPolyhedron = false;
  fpPolyhedron = nullptr;
}

References G4VCSGface::Clone(), G4VCSGfaceted::faces, G4VCSGfaceted::fCubicVolume, G4VCSGfaceted::fpPolyhedron, G4VCSGfaceted::fRebuildPolyhedron, G4VCSGfaceted::fSurfaceArea, and G4VCSGfaceted::numFace.

Referenced by G4VCSGfaceted::G4VCSGfaceted(), and G4VCSGfaceted::operator=().

Create()

void G4GenericPolycone::Create ( G4double  phiStart, G4double  phiTotal, G4ReduciblePolygon *  rz  )

protected

Definition at line 84 of file G4GenericPolycone.cc.

{
  //
  // Perform checks of rz values
  //
  if (rz->Amin() < 0.0)
  {
    std::ostringstream message;
    message << "Illegal input parameters - " << GetName() << G4endl
            << "        All R values must be >= 0 !";
    G4Exception("G4GenericPolycone::Create()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  G4double rzArea = rz->Area();
  if (rzArea < -kCarTolerance)
  {
    rz->ReverseOrder();
  }
  else if (rzArea < kCarTolerance)
  {
    std::ostringstream message;
    message << "Illegal input parameters - " << GetName() << G4endl
            << "        R/Z cross section is zero or near zero: " << rzArea;
    G4Exception("G4GenericPolycone::Create()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  if ( (!rz->RemoveDuplicateVertices( kCarTolerance ))
    || (!rz->RemoveRedundantVertices( kCarTolerance ))     )
  {
    std::ostringstream message;
    message << "Illegal input parameters - " << GetName() << G4endl
            << "        Too few unique R/Z values !";
    G4Exception("G4GenericPolycone::Create()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  if (rz->CrossesItself(1/kInfinity))
  {
    std::ostringstream message;
    message << "Illegal input parameters - " << GetName() << G4endl
            << "        R/Z segments cross !";
    G4Exception("G4GenericPolycone::Create()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  numCorner = rz->NumVertices();
 
  //
  // Phi opening? Account for some possible roundoff, and interpret
  // nonsense value as representing no phi opening
  //
  if (phiTotal <= 0 || phiTotal > twopi-1E-10)
  {
    phiIsOpen = false;
    startPhi = 0;
    endPhi = twopi;
  }
  else
  {
    phiIsOpen = true;
 
    //
    // Convert phi into our convention
    //
    startPhi = phiStart;
    while( startPhi < 0 )    // Loop checking, 13.08.2015, G.Cosmo
      startPhi += twopi;
 
    endPhi = phiStart+phiTotal;
    while( endPhi < startPhi )    // Loop checking, 13.08.2015, G.Cosmo
      endPhi += twopi;
  }
 
  //
  // Allocate corner array.
  //
  corners = new G4PolyconeSideRZ[numCorner];
 
  //
  // Copy corners
  //
  G4ReduciblePolygonIterator iterRZ(rz);
 
  G4PolyconeSideRZ* next = corners;
  iterRZ.Begin();
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    next->r = iterRZ.GetA();
    next->z = iterRZ.GetB();
  } while( ++next, iterRZ.Next() );
 
  //
  // Allocate face pointer array
  //
  numFace = phiIsOpen ? numCorner+2 : numCorner;
  faces = new G4VCSGface*[numFace];
 
  //
  // Construct conical faces
  //
  // But! Don't construct a face if both points are at zero radius!
  //
  G4PolyconeSideRZ *corner = corners,
                   *prev = corners + numCorner-1,
                   *nextNext;
  G4VCSGface** face = faces;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    next = corner+1;
    if (next >= corners+numCorner) next = corners;
    nextNext = next+1;
    if (nextNext >= corners+numCorner) nextNext = corners;
 
    if (corner->r < 1/kInfinity && next->r < 1/kInfinity) continue;
 
    //
    // We must decide here if we can dare declare one of our faces
    // as having a "valid" normal (i.e. allBehind = true). This
    // is never possible if the face faces "inward" in r.
    //
    G4bool allBehind;
    if (corner->z > next->z)
    {
      allBehind = false;
    }
    else
    {
      //
      // Otherwise, it is only true if the line passing
      // through the two points of the segment do not
      // split the r/z cross section
      //
      allBehind = !rz->BisectedBy( corner->r, corner->z,
                 next->r, next->z, kCarTolerance );
    }
 
    *face++ = new G4PolyconeSide( prev, corner, next, nextNext,
                startPhi, endPhi-startPhi, phiIsOpen, allBehind );
  } while( prev=corner, corner=next, corner > corners );
 
  if (phiIsOpen)
  {
    //
    // Construct phi open edges
    //
    *face++ = new G4PolyPhiFace( rz, startPhi, 0, endPhi  );
    *face++ = new G4PolyPhiFace( rz, endPhi,   0, startPhi );
  }
 
  //
  // We might have dropped a face or two: recalculate numFace
  //
  numFace = face-faces;
 
  //
  // Make enclosingCylinder
  //
  enclosingCylinder =
    new G4EnclosingCylinder( rz, phiIsOpen, phiStart, phiTotal );
}

References G4ReduciblePolygon::Amin(), G4ReduciblePolygon::Area(), G4ReduciblePolygonIterator::Begin(), G4ReduciblePolygon::BisectedBy(), corners, G4ReduciblePolygon::CrossesItself(), enclosingCylinder, endPhi, G4VCSGfaceted::faces, FatalErrorInArgument, G4endl, G4Exception(), G4ReduciblePolygonIterator::GetA(), G4ReduciblePolygonIterator::GetB(), G4VSolid::GetName(), G4VSolid::kCarTolerance, kInfinity, G4ReduciblePolygonIterator::Next(), numCorner, G4VCSGfaceted::numFace, G4ReduciblePolygon::NumVertices(), phiIsOpen, G4PolyconeSideRZ::r, G4ReduciblePolygon::RemoveDuplicateVertices(), G4ReduciblePolygon::RemoveRedundantVertices(), G4ReduciblePolygon::ReverseOrder(), startPhi, twopi, and G4PolyconeSideRZ::z.

Referenced by G4GenericPolycone().

CreatePolyhedron()

G4Polyhedron * G4GenericPolycone::CreatePolyhedron ( ) const

virtual

Implements G4VCSGfaceted.

Definition at line 825 of file G4GenericPolycone.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);
}

References corners, endPhi, numCorner, and startPhi.

DeleteStuff()

void G4VCSGfaceted::DeleteStuff ( )

protectedinherited

Definition at line 150 of file G4VCSGfaceted.cc.

{
  if (numFace)
  {
    G4VCSGface **face = faces;
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      delete *face;
    } while( ++face < faces + numFace );
 
    delete [] faces;
  }
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

References G4VCSGfaceted::faces, G4VCSGfaceted::fpPolyhedron, and G4VCSGfaceted::numFace.

Referenced by G4VCSGfaceted::operator=(), G4Polycone::Reset(), G4Polyhedra::Reset(), and G4VCSGfaceted::~G4VCSGfaceted().

DescribeYourselfTo()

void G4VCSGfaceted::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtualinherited

Implements G4VSolid.

Definition at line 396 of file G4VCSGfaceted.cc.

{
   scene.AddSolid( *this );
}

References G4VGraphicsScene::AddSolid().

DistanceTo()

G4double G4VCSGfaceted::DistanceTo ( const G4ThreeVector &  p, const G4bool  outgoing  ) const

protectedvirtualinherited

Definition at line 378 of file G4VCSGfaceted.cc.

{
  G4VCSGface **face = faces;
  G4double best = kInfinity;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double distance = (*face)->Distance( p, outgoing );
    if (distance < best)  { best = distance; }
  } while( ++face < faces + numFace );
 
  return (best < 0.5*kCarTolerance) ? 0. : best;
}

References G4VCSGfaceted::faces, G4VSolid::kCarTolerance, kInfinity, and G4VCSGfaceted::numFace.

Referenced by G4VCSGfaceted::DistanceToIn(), and G4VCSGfaceted::DistanceToOut().

DistanceToIn() [1/2]

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 392 of file G4GenericPolycone.cc.

{
  return G4VCSGfaceted::DistanceToIn(p);
}

References G4VCSGfaceted::DistanceToIn().

DistanceToIn() [2/2]

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 375 of file G4GenericPolycone.cc.

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

References G4VCSGfaceted::DistanceToIn(), enclosingCylinder, kInfinity, and G4EnclosingCylinder::ShouldMiss().

DistanceToOut() [1/2]

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

virtualinherited

Implements G4VSolid.

Definition at line 367 of file G4VCSGfaceted.cc.

{
  return DistanceTo( p, true );
}

References G4VCSGfaceted::DistanceTo().

DistanceToOut() [2/2]

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

virtualinherited

Implements G4VSolid.

Definition at line 299 of file G4VCSGfaceted.cc.

{
  G4bool allBehind = true;
  G4double distance = kInfinity;
  G4double distFromSurface = kInfinity;
  G4ThreeVector normal;
  
  G4VCSGface **face = faces;
  G4VCSGface *bestFace = *face;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double  faceDistance,
              faceDistFromSurface;
    G4ThreeVector  faceNormal;
    G4bool    faceAllBehind;
    if ((*face)->Intersect( p, v, true, kCarTolerance/2,
                faceDistance, faceDistFromSurface,
                faceNormal, faceAllBehind ) )
    {
      //
      // Intersecting face
      //
      if ( (distance < kInfinity) || (!faceAllBehind) )  { allBehind = false; }
      if (faceDistance < distance)
      {
        distance = faceDistance;
        distFromSurface = faceDistFromSurface;
        normal = faceNormal;
        bestFace = *face;
        if (distFromSurface <= 0.)  { break; }
      }
    }
  } while( ++face < faces + numFace );
  
  if (distance < kInfinity)
  {
    if (distFromSurface <= 0.)
    {
      distance = 0.;
    }
    else if (distFromSurface<kCarTolerance/2)
    {
      if (bestFace->Distance(p,true) < kCarTolerance/2)  { distance = 0.; }
    }
 
    if (calcNorm)
    {
      *validNorm = allBehind;
      *n = normal;
    }
  }
  else
  { 
    if (Inside(p) == kSurface)  { distance = 0.; }
    if (calcNorm)  { *validNorm = false; }
  }
 
  return distance;
}

References G4VCSGface::Distance(), G4VCSGfaceted::faces, G4VCSGfaceted::Inside(), G4VSolid::kCarTolerance, kInfinity, kSurface, CLHEP::detail::n, CLHEP::normal(), and G4VCSGfaceted::numFace.

DumpInfo()

void G4VSolid::DumpInfo ( ) const

inlineinherited

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

EstimateCubicVolume()

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

inherited

Definition at line 203 of file G4VSolid.cc.

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

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

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

EstimateSurfaceArea()

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

inherited

Definition at line 265 of file G4VSolid.cc.

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

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

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

GetAreaAccuracy()

G4double G4VCSGfaceted::GetAreaAccuracy ( ) const

inherited

Definition at line 514 of file G4VCSGfaceted.cc.

{
  return fAreaAccuracy;
}

References G4VCSGfaceted::fAreaAccuracy.

GetAreaStatistics()

G4int G4VCSGfaceted::GetAreaStatistics ( ) const

inherited

Definition at line 505 of file G4VCSGfaceted.cc.

{
  return fStatistics;
}

References G4VCSGfaceted::fStatistics.

GetConstituentSolid() [1/2]

G4VSolid * G4VSolid::GetConstituentSolid ( G4int  no )

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 170 of file G4VSolid.cc.

{ return nullptr; }

GetConstituentSolid() [2/2]

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

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 167 of file G4VSolid.cc.

{ return nullptr; }

Referenced by G4BooleanSolid::StackPolyhedron().

GetCorner()

G4PolyconeSideRZ G4GenericPolycone::GetCorner ( G4int  index ) const

inline

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

GetCosEndPhi()

G4double G4GenericPolycone::GetCosEndPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetCosStartPhi()

G4double G4GenericPolycone::GetCosStartPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetCubicVolume()

G4double G4GenericPolycone::GetCubicVolume ( )

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 636 of file G4GenericPolycone.cc.

{
  if (fCubicVolume == 0.)
  {
    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.;
  }
  return fCubicVolume;
}

References G4VCSGfaceted::fCubicVolume, GetCorner(), GetEndPhi(), GetNumRZCorner(), GetStartPhi(), G4PolyconeSideRZ::r, G4INCL::CrossSections::total(), and G4PolyconeSideRZ::z.

GetCubVolEpsilon()

G4double G4VCSGfaceted::GetCubVolEpsilon ( ) const

inherited

Definition at line 476 of file G4VCSGfaceted.cc.

{
  return fCubVolEpsilon;
}

References G4VCSGfaceted::fCubVolEpsilon.

GetCubVolStatistics()

G4int G4VCSGfaceted::GetCubVolStatistics ( ) const

inherited

Definition at line 467 of file G4VCSGfaceted.cc.

{
  return fStatistics;
}

References G4VCSGfaceted::fStatistics.

GetDisplacedSolidPtr() [1/2]

G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( )

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 176 of file G4VSolid.cc.

{ return nullptr; }

GetDisplacedSolidPtr() [2/2]

const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( ) const

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 173 of file G4VSolid.cc.

{ return nullptr; }

GetEndPhi()

G4double G4GenericPolycone::GetEndPhi ( ) const

inline

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

GetEntityType()

G4GeometryType G4GenericPolycone::GetEntityType ( ) const

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 589 of file G4GenericPolycone.cc.

{
  return G4String("G4GenericPolycone");
}

GetExtent()

G4VisExtent G4VCSGfaceted::GetExtent ( ) const

virtualinherited

Reimplemented from G4VSolid.

Definition at line 407 of file G4VCSGfaceted.cc.

{
  static const G4ThreeVector xMax(1,0,0), xMin(-1,0,0),
                             yMax(0,1,0), yMin(0,-1,0),
                             zMax(0,0,1), zMin(0,0,-1);
  static const G4ThreeVector *axes[6] =
     { &xMin, &xMax, &yMin, &yMax, &zMin, &zMax };
  
  G4double answers[6] =
     {-kInfinity, -kInfinity, -kInfinity, -kInfinity, -kInfinity, -kInfinity};
 
  G4VCSGface **face = faces;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {    
    const G4ThreeVector **axis = axes+5 ;
    G4double* answer = answers+5;
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      G4double testFace = (*face)->Extent( **axis );
      if (testFace > *answer)  { *answer = testFace; }
    }
    while( --axis, --answer >= answers );
    
  } while( ++face < faces + numFace );
  
    return G4VisExtent( -answers[0], answers[1], 
                        -answers[2], answers[3],
                        -answers[4], answers[5]  );
}

References G4VCSGfaceted::faces, kInfinity, and G4VCSGfaceted::numFace.

GetName()

G4String G4VSolid::GetName ( ) const

inlineinherited

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

GetNumRZCorner()

G4int G4GenericPolycone::GetNumRZCorner ( ) const

inline

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

GetPointOnSurface()

G4ThreeVector G4GenericPolycone::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 760 of file G4GenericPolycone.cc.

{
  // Set surface elements
  if (!fElements)
  {
    G4AutoLock l(&surface_elementsMutex);
    SetSurfaceElements();
    l.unlock();
  }
 
  // Select surface element
  G4GenericPolycone::surface_element selem;
  selem = fElements->back();
  G4double select = selem.area*G4QuickRand();
  auto it = std::lower_bound(fElements->begin(), fElements->end(), select,
                             [](const G4GenericPolycone::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 G4ThreeVector(r*std::cos(phi), r*std::sin(phi), z);
}

References G4GenericPolycone::surface_element::area, fElements, G4QuickRand(), GetCorner(), GetEndPhi(), GetNumRZCorner(), GetStartPhi(), G4VSolid::kCarTolerance, G4PolyconeSideRZ::r, SetSurfaceElements(), anonymous_namespace{G4GenericPolycone.cc}::surface_elementsMutex, G4TemplateAutoLock< _Mutex_t >::unlock(), and G4PolyconeSideRZ::z.

GetPointOnSurfaceGeneric()

G4ThreeVector G4VCSGfaceted::GetPointOnSurfaceGeneric ( ) const

protectedinherited

Definition at line 586 of file G4VCSGfaceted.cc.

{
  // Preparing variables
  //
  G4ThreeVector answer=G4ThreeVector(0.,0.,0.);
  G4VCSGface **face = faces;
  G4double area = 0.;
  G4int i;
  std::vector<G4double> areas; 
 
  // First step: calculate surface areas
  //
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double result = (*face)->SurfaceArea( );
    areas.push_back(result);
    area=area+result;
  } while( ++face < faces + numFace );
 
  // Second Step: choose randomly one surface
  //
  G4VCSGface **face1 = faces;
  G4double chose = area*G4UniformRand();
  G4double Achose1, Achose2;
  Achose1=0.; Achose2=0.; 
  i=0;
 
  do
  {
    Achose2+=areas[i];
    if(chose>=Achose1 && chose<Achose2)
    {
      G4ThreeVector point;
      point= (*face1)->GetPointOnFace();
      return point;
    }
    ++i;
    Achose1=Achose2;
  } while( ++face1 < faces + numFace );
 
  return answer;
}

References G4VCSGfaceted::faces, G4UniformRand, G4VCSGfaceted::numFace, and G4VCSGface::SurfaceArea().

GetPolyhedron()

G4Polyhedron * G4VCSGfaceted::GetPolyhedron ( ) const

virtualinherited

Reimplemented from G4VSolid.

Definition at line 565 of file G4VCSGfaceted.cc.

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

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

GetSinEndPhi()

G4double G4GenericPolycone::GetSinEndPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetSinStartPhi()

G4double G4GenericPolycone::GetSinStartPhi ( ) const

inline

Referenced by BoundingLimits(), and CalculateExtent().

GetStartPhi()

G4double G4GenericPolycone::GetStartPhi ( ) const

inline

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

GetSurfaceArea()

G4double G4GenericPolycone::GetSurfaceArea ( )

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 658 of file G4GenericPolycone.cc.

{
  if (fSurfaceArea == 0.)
  {
    // 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;
  }
  return fSurfaceArea;
}

References G4VCSGfaceted::fSurfaceArea, GetCorner(), GetEndPhi(), GetNumRZCorner(), GetStartPhi(), IsOpen(), G4PolyconeSideRZ::r, and G4PolyconeSideRZ::z.

GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

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

Inside()

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 357 of file G4GenericPolycone.cc.

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

References enclosingCylinder, G4VCSGfaceted::Inside(), kOutside, and G4EnclosingCylinder::MustBeOutside().

IsOpen()

G4bool G4GenericPolycone::IsOpen ( ) const

inline

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

operator=()

G4GenericPolycone & G4GenericPolycone::operator=

(

const G4GenericPolycone &

source

)

Definition at line 282 of file G4GenericPolycone.cc.

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

References CopyStuff(), corners, enclosingCylinder, and G4VCSGfaceted::operator=().

operator==()

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

inlineinherited

Reset()

G4bool G4GenericPolycone::Reset

(

)

Definition at line 342 of file G4GenericPolycone.cc.

{
  std::ostringstream message;
  message << "Solid " << GetName() << " built using generic construct."
          << G4endl << "Not applicable to the generic construct !";
  G4Exception("G4GenericPolycone::Reset()", "GeomSolids1001",
              JustWarning, message, "Parameters NOT resetted.");
  return true;
}

References G4endl, G4Exception(), G4VSolid::GetName(), and JustWarning.

SetAreaAccuracy()

void G4VCSGfaceted::SetAreaAccuracy ( G4double  ep )

inherited

Definition at line 533 of file G4VCSGfaceted.cc.

{
  fSurfaceArea=0.;
  fAreaAccuracy=ep;
}

References G4VCSGfaceted::fAreaAccuracy, and G4VCSGfaceted::fSurfaceArea.

SetAreaStatistics()

void G4VCSGfaceted::SetAreaStatistics ( G4int  st )

inherited

Definition at line 523 of file G4VCSGfaceted.cc.

{
  fSurfaceArea=0.;
  fStatistics=st;
}

References G4VCSGfaceted::fStatistics, and G4VCSGfaceted::fSurfaceArea.

SetCubVolEpsilon()

void G4VCSGfaceted::SetCubVolEpsilon ( G4double  ep )

inherited

Definition at line 495 of file G4VCSGfaceted.cc.

{
  fCubicVolume=0.;
  fCubVolEpsilon=ep;
}

References G4VCSGfaceted::fCubicVolume, and G4VCSGfaceted::fCubVolEpsilon.

SetCubVolStatistics()

void G4VCSGfaceted::SetCubVolStatistics ( G4int  st )

inherited

Definition at line 485 of file G4VCSGfaceted.cc.

{
  fCubicVolume=0.;
  fStatistics=st;
}

References G4VCSGfaceted::fCubicVolume, and G4VCSGfaceted::fStatistics.

SetName()

void G4VSolid::SetName ( const G4String &  name )

inherited

Definition at line 127 of file G4VSolid.cc.

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

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

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

SetSurfaceElements()

void G4GenericPolycone::SetSurfaceElements ( ) const

protected

Definition at line 697 of file G4GenericPolycone.cc.

{
  fElements = new std::vector<G4GenericPolycone::surface_element>;
  G4double sarea = 0.;
  G4int nrz = GetNumRZCorner();
 
  // set lateral surface elements
  G4double dphi = GetEndPhi() - GetStartPhi();
  G4int ia = nrz - 1;
  for (G4int ib=0; ib<nrz; ++ib)
  {
    G4PolyconeSideRZ a = GetCorner(ia);
    G4PolyconeSideRZ b = GetCorner(ib);
    G4GenericPolycone::surface_element selem;
    selem.i0 = ia;
    selem.i1 = ib;
    selem.i2 = -1;
    ia = ib;
    if (a.r == 0. && b.r == 0.) continue;
    G4double h = std::sqrt((b.r - a.r)*(b.r - a.r) + (b.z - a.z)*(b.z - a.z));
    sarea += 0.5*dphi*(b.r + a.r)*h;
    selem.area = sarea;
    fElements->push_back(selem);
  }
 
  // set elements for phi cuts
  if (IsOpen())
  {
    G4TwoVectorList contourRZ;
    std::vector<G4int> triangles;
    for (G4int i=0; i<nrz; ++i)
    {
      G4PolyconeSideRZ corner = GetCorner(i);
      contourRZ.push_back(G4TwoVector(corner.r, corner.z));
    }
    G4GeomTools::TriangulatePolygon(contourRZ, triangles);
    G4int ntria = triangles.size();
    for (G4int i=0; i<ntria; i+=3)
    {
      G4GenericPolycone::surface_element selem;
      selem.i0 = triangles[i];
      selem.i1 = triangles[i+1];
      selem.i2 = triangles[i+2];
      G4PolyconeSideRZ a = GetCorner(selem.i0);
      G4PolyconeSideRZ b = GetCorner(selem.i1);
      G4PolyconeSideRZ c = GetCorner(selem.i2);
      G4double stria =
        std::abs(G4GeomTools::TriangleArea(a.r, a.z, b.r, b.z, c.r, c.z));
      sarea += stria;
      selem.area = sarea;
      fElements->push_back(selem); // start phi
      sarea += stria;
      selem.area = sarea;
      selem.i0 += nrz;
      fElements->push_back(selem); // end phi
    }
  }
}

References G4GenericPolycone::surface_element::area, fElements, GetCorner(), GetEndPhi(), GetNumRZCorner(), GetStartPhi(), G4GenericPolycone::surface_element::i0, G4GenericPolycone::surface_element::i1, G4GenericPolycone::surface_element::i2, IsOpen(), G4PolyconeSideRZ::r, G4GeomTools::TriangleArea(), G4GeomTools::TriangulatePolygon(), and G4PolyconeSideRZ::z.

Referenced by GetPointOnSurface().

StreamInfo()

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 607 of file G4GenericPolycone.cc.

{
  G4int oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4GenericPolycone\n"
     << " Parameters: \n"
     << "    starting phi angle : " << startPhi/degree << " degrees \n"
     << "    ending phi angle   : " << endPhi/degree << " degrees \n";
  G4int i=0;
 
  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;
}

References corners, degree, endPhi, G4VSolid::GetName(), numCorner, G4PolyconeSideRZ::r, startPhi, and G4PolyconeSideRZ::z.

SurfaceNormal()

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

virtualinherited

Implements G4VSolid.

Definition at line 225 of file G4VCSGfaceted.cc.

{
  G4ThreeVector answer;
  G4VCSGface **face = faces;
  G4double best = kInfinity;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double distance;
    G4ThreeVector normal = (*face)->Normal( p, &distance );
    if (distance < best)
    {
      best = distance;
      answer = normal;
    }
  } while( ++face < faces + numFace );
 
  return answer;
}

References G4VCSGfaceted::faces, kInfinity, CLHEP::normal(), and G4VCSGfaceted::numFace.

Field Documentation

corners

G4PolyconeSideRZ* G4GenericPolycone::corners = nullptr

protected

Definition at line 151 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), Create(), CreatePolyhedron(), operator=(), StreamInfo(), and ~G4GenericPolycone().

enclosingCylinder

G4EnclosingCylinder* G4GenericPolycone::enclosingCylinder = nullptr

protected

Definition at line 153 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), Create(), DistanceToIn(), Inside(), operator=(), and ~G4GenericPolycone().

endPhi

G4double G4GenericPolycone::endPhi

protected

Definition at line 148 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), Create(), CreatePolyhedron(), and StreamInfo().

faces

G4VCSGface** G4VCSGfaceted::faces = nullptr

protectedinherited

Definition at line 110 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::CalculateExtent(), G4VCSGfaceted::CopyStuff(), G4Polyhedra::Create(), Create(), G4Polycone::Create(), G4VCSGfaceted::DeleteStuff(), G4VCSGfaceted::DistanceTo(), G4VCSGfaceted::DistanceToIn(), G4VCSGfaceted::DistanceToOut(), G4VCSGfaceted::GetExtent(), G4VCSGfaceted::GetPointOnSurfaceGeneric(), G4VCSGfaceted::Inside(), and G4VCSGfaceted::SurfaceNormal().

fAreaAccuracy

G4double G4VCSGfaceted::fAreaAccuracy

privateinherited

Definition at line 130 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::G4VCSGfaceted(), G4VCSGfaceted::GetAreaAccuracy(), G4VCSGfaceted::GetSurfaceArea(), G4VCSGfaceted::operator=(), and G4VCSGfaceted::SetAreaAccuracy().

fCubicVolume

G4double G4VCSGfaceted::fCubicVolume = 0.0

protectedinherited

Definition at line 111 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::CopyStuff(), GetCubicVolume(), G4Polycone::GetCubicVolume(), G4Polyhedra::GetCubicVolume(), G4VCSGfaceted::GetCubicVolume(), G4VCSGfaceted::SetCubVolEpsilon(), and G4VCSGfaceted::SetCubVolStatistics().

fCubVolEpsilon

G4double G4VCSGfaceted::fCubVolEpsilon

privateinherited

Definition at line 129 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::G4VCSGfaceted(), G4VCSGfaceted::GetCubicVolume(), G4VCSGfaceted::GetCubVolEpsilon(), G4VCSGfaceted::operator=(), and G4VCSGfaceted::SetCubVolEpsilon().

fElements

std::vector<surface_element>* G4GenericPolycone::fElements = nullptr

mutableprotected

Definition at line 156 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), GetPointOnSurface(), SetSurfaceElements(), and ~G4GenericPolycone().

fpPolyhedron

G4Polyhedron* G4VCSGfaceted::fpPolyhedron = nullptr

mutableprotectedinherited

Definition at line 114 of file G4VCSGfaceted.hh.

Referenced by CopyStuff(), G4Polycone::CopyStuff(), G4Polyhedra::CopyStuff(), G4VCSGfaceted::CopyStuff(), G4VCSGfaceted::DeleteStuff(), G4VCSGfaceted::GetPolyhedron(), ~G4GenericPolycone(), G4Polycone::~G4Polycone(), G4Polyhedra::~G4Polyhedra(), and G4VCSGfaceted::~G4VCSGfaceted().

fRebuildPolyhedron

G4bool G4VCSGfaceted::fRebuildPolyhedron = false

mutableprotectedinherited

Definition at line 113 of file G4VCSGfaceted.hh.

Referenced by CopyStuff(), G4Polycone::CopyStuff(), G4Polyhedra::CopyStuff(), G4VCSGfaceted::CopyStuff(), and G4VCSGfaceted::GetPolyhedron().

fshapeName

G4String G4VSolid::fshapeName

privateinherited

Definition at line 312 of file G4VSolid.hh.

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

fStatistics

G4int G4VCSGfaceted::fStatistics

privateinherited

Definition at line 128 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::G4VCSGfaceted(), G4VCSGfaceted::GetAreaStatistics(), G4VCSGfaceted::GetCubicVolume(), G4VCSGfaceted::GetCubVolStatistics(), G4VCSGfaceted::GetSurfaceArea(), G4VCSGfaceted::operator=(), G4VCSGfaceted::SetAreaStatistics(), and G4VCSGfaceted::SetCubVolStatistics().

fSurfaceArea

G4double G4VCSGfaceted::fSurfaceArea = 0.0

protectedinherited

Definition at line 112 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::CopyStuff(), GetSurfaceArea(), G4Polycone::GetSurfaceArea(), G4Polyhedra::GetSurfaceArea(), G4VCSGfaceted::GetSurfaceArea(), G4VCSGfaceted::SetAreaAccuracy(), and G4VCSGfaceted::SetAreaStatistics().

kCarTolerance

G4double G4VSolid::kCarTolerance

protectedinherited

Definition at line 299 of file G4VSolid.hh.

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

numCorner

G4int G4GenericPolycone::numCorner

protected

Definition at line 150 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), Create(), CreatePolyhedron(), and StreamInfo().

numFace

G4int G4VCSGfaceted::numFace = 0

protectedinherited

Definition at line 109 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::CalculateExtent(), G4VCSGfaceted::CopyStuff(), G4Polyhedra::Create(), Create(), G4Polycone::Create(), G4VCSGfaceted::DeleteStuff(), G4VCSGfaceted::DistanceTo(), G4VCSGfaceted::DistanceToIn(), G4VCSGfaceted::DistanceToOut(), G4VCSGfaceted::GetExtent(), G4VCSGfaceted::GetPointOnSurfaceGeneric(), G4VCSGfaceted::Inside(), G4VCSGfaceted::StreamInfo(), and G4VCSGfaceted::SurfaceNormal().

phiIsOpen

G4bool G4GenericPolycone::phiIsOpen = false

protected

Definition at line 149 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), and Create().

startPhi

G4double G4GenericPolycone::startPhi

protected

Definition at line 147 of file G4GenericPolycone.hh.

Referenced by CopyStuff(), Create(), CreatePolyhedron(), and StreamInfo().

---

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

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