G4Polycone Class Reference

#include <G4Polycone.hh>

Inheritance diagram for G4Polycone:

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
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
	G4Polycone (__void__ &)
	G4Polycone (const G4Polycone &source)
	G4Polycone (const G4String &name, G4double phiStart, G4double phiTotal, G4int numRZ, const G4double r[], const G4double z[])
	G4Polycone (const G4String &name, G4double phiStart, G4double phiTotal, G4int numZPlanes, const G4double zPlane[], const G4double rInner[], const G4double rOuter[])
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
G4PolyconeHistorical *	GetOriginalParameters () 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
G4Polycone &	operator= (const G4Polycone &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)
void	SetOriginalParameters (G4PolyconeHistorical *pars)
std::ostream &	StreamInfo (std::ostream &os) const
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const
virtual	~G4Polycone ()

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 G4Polycone &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
G4bool	SetOriginalParameters (G4ReduciblePolygon *rz)
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
G4PolyconeHistorical *	original_parameters = nullptr
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 75 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[]
	)

Definition at line 58 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
  //
  G4ReduciblePolygon *rz =
    new G4ReduciblePolygon( rInner, rOuter, zPlane, numZPlanes );
 
  //
  // Do the real work
  //
  Create( phiStart, phiTotal, rz );
 
  delete rz;
}

References Create(), G4VSolid::DumpInfo(), FatalErrorInArgument, G4endl, G4Exception(), G4PolyconeHistorical::Num_z_planes, G4PolyconeHistorical::Opening_angle, original_parameters, G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, G4PolyconeHistorical::Start_angle, and G4PolyconeHistorical::Z_values.

Referenced by Clone().

G4Polycone() [2/4]

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

Definition at line 132 of file G4Polycone.cc.

  : G4VCSGfaceted( name )
{
 
  G4ReduciblePolygon* 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;
}

References Create(), FatalException, G4cout, G4endl, G4Exception(), G4VSolid::GetName(), and SetOriginalParameters().

~G4Polycone()

G4Polycone::~G4Polycone ( )

virtual

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

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

G4Polycone() [3/4]

G4Polycone::G4Polycone

(

__void__ &

a

)

Definition at line 333 of file G4Polycone.cc.

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

G4Polycone() [4/4]

G4Polycone::G4Polycone

(

const G4Polycone &

source

)

Definition at line 358 of file G4Polycone.cc.

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

References CopyStuff().

Member Function Documentation

BoundingLimits()

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

virtual

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

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 G4Polycone::CalculateExtent ( const EAxis  pAxis, const G4VoxelLimits &  pVoxelLimit, const G4AffineTransform &  pTransform, G4double &  pmin, G4double &  pmax  ) const

virtual

Reimplemented from G4VCSGfaceted.

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) ? 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;
  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.push_back(G4TwoVector(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 = 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, G4VSolid::kCarTolerance, kInfinity, pMax, pMin, G4GeomTools::PolygonArea(), G4PolyconeSideRZ::r, G4GeomTools::RemoveRedundantVertices(), 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 * G4Polycone::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 704 of file G4Polycone.cc.

{
  return new G4Polycone(*this);
}

References G4Polycone().

ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 688 of file G4Polycone.cc.

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

References G4VPVParameterisation::ComputeDimensions(), and CLHEP::detail::n.

CopyStuff() [1/2]

void G4Polycone::CopyStuff ( const G4Polycone &  source )

protected

Definition at line 384 of file G4Polycone.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 );
 
  //
  // Original parameters
  //
  if (source.original_parameters)
  {
    original_parameters =
      new G4PolyconeHistorical( *source.original_parameters );
  }
 
  //
  // 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, original_parameters, phiIsOpen, and startPhi.

Referenced by G4Polycone(), 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 G4Polycone::Create ( G4double  phiStart, G4double  phiTotal, G4ReduciblePolygon *  rz  )

protected

Definition at line 172 of file G4Polycone.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("G4Polycone::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("G4Polycone::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("G4Polycone::Create()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  if (rz->CrossesItself(1/kInfinity))
  {
    std::ostringstream message;
    message << "Illegal input parameters - " << GetName() << G4endl
            << "        R/Z segments cross !";
    G4Exception("G4Polycone::Create()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  numCorner = rz->NumVertices();
 
  startPhi = phiStart;
  while( startPhi < 0. )    // Loop checking, 13.08.2015, G.Cosmo
    startPhi += twopi;
  //
  // Phi opening? Account for some possible roundoff, and interpret
  // nonsense value as representing no phi opening
  //
  if ( (phiTotal <= 0) || (phiTotal > twopi*(1-DBL_EPSILON)) )
  {
    phiIsOpen = false;
    startPhi = 0.;
    endPhi = twopi;
  }
  else
  {
    phiIsOpen = true;
    endPhi = startPhi + phiTotal;
  }
 
  //
  // 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(), DBL_EPSILON, 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 G4Polycone(), and Reset().

CreatePolyhedron()

G4Polyhedron * G4Polycone::CreatePolyhedron ( ) const

virtual

Implements G4VCSGfaceted.

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

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=(), 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 G4Polycone::DistanceToIn ( const G4ThreeVector &  p ) const

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 504 of file G4Polycone.cc.

{
  return G4VCSGfaceted::DistanceToIn(p);
}

References G4VCSGfaceted::DistanceToIn().

DistanceToIn() [2/2]

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 487 of file G4Polycone.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(), G4GenericPolycone::BoundingLimits(), G4GenericTrap::BoundingLimits(), G4Hype::BoundingLimits(), G4Paraboloid::BoundingLimits(), 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(), 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 G4Polycone::GetCorner ( G4int  index ) const

inline

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

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 ( )

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 762 of file G4Polycone.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 G4Polycone::GetEndPhi ( ) const

inline

Referenced by G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), export_G4Polycone(), G4ParameterisationPolyconePhi::G4ParameterisationPolyconePhi(), G4VParameterisationPolycone::G4VParameterisationPolycone(), GetCubicVolume(), G4ParameterisationPolyconePhi::GetMaxParameter(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), GetSurfaceArea(), and SetSurfaceElements().

GetEntityType()

G4GeometryType G4Polycone::GetEntityType ( ) const

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 697 of file G4Polycone.cc.

{
  return G4String("G4Polycone");
}

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(), G4GenericPolycone::BoundingLimits(), G4GenericTrap::BoundingLimits(), G4Hype::BoundingLimits(), G4Paraboloid::BoundingLimits(), BoundingLimits(), G4Polyhedra::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4GDMLWriteSolids::BoxWrite(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), 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(), G4GenericPolycone::Create(), 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(), 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(), G4GenericPolycone::Reset(), G4Polyhedra::Reset(), G4VoxelSafety::SafetyForVoxelNode(), G4GDMLWriteSolids::ScaledWrite(), G4Torus::SetAllParameters(), G4Tet::SetBoundingLimits(), 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(), G4GenericPolycone::StreamInfo(), G4GenericTrap::StreamInfo(), G4Hype::StreamInfo(), G4Paraboloid::StreamInfo(), 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 G4Polycone::GetNumRZCorner ( ) const

inline

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

GetOriginalParameters()

G4PolyconeHistorical * G4Polycone::GetOriginalParameters ( ) const

inline

Referenced by G4tgbVolume::BuildSolidForDivision(), G4GDMLParameterisation::ComputeDimensions(), G4ParameterisationPolyconeRho::ComputeDimensions(), G4ParameterisationPolyconePhi::ComputeDimensions(), G4ParameterisationPolyconeRho::G4ParameterisationPolyconeRho(), G4VParameterisationPolycone::G4VParameterisationPolycone(), G4ParameterisationPolyconeRho::GetMaxParameter(), G4GDMLWriteParamvol::Polycone_dimensionsWrite(), and G4GDMLWriteSolids::PolyconeWrite().

GetPointOnSurface()

G4ThreeVector G4Polycone::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 886 of file G4Polycone.cc.

{
  // Set surface elements
  if (!fElements)
  {
    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 G4ThreeVector(r*std::cos(phi), r*std::sin(phi), z);
}

References G4Polycone::surface_element::area, fElements, G4QuickRand(), GetCorner(), GetEndPhi(), GetNumRZCorner(), GetStartPhi(), G4VSolid::kCarTolerance, G4PolyconeSideRZ::r, SetSurfaceElements(), anonymous_namespace{G4Polycone.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 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

Referenced by G4tgbVolume::BuildSolidForDivision(), CalculateExtent(), export_G4Polycone(), G4ParameterisationPolyconePhi::G4ParameterisationPolyconePhi(), G4VParameterisationPolycone::G4VParameterisationPolycone(), GetCubicVolume(), G4ParameterisationPolyconePhi::GetMaxParameter(), GetPointOnSurface(), G4tgbGeometryDumper::GetSolidParams(), GetSurfaceArea(), and SetSurfaceElements().

GetSurfaceArea()

G4double G4Polycone::GetSurfaceArea ( )

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 784 of file G4Polycone.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 G4Polycone::Inside ( const G4ThreeVector &  p ) const

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 469 of file G4Polycone.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 G4Polycone::IsOpen ( ) const

inline

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

operator=()

G4Polycone & G4Polycone::operator=

(

const G4Polycone &

source

)

Definition at line 366 of file G4Polycone.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, G4VCSGfaceted::operator=(), and original_parameters.

operator==()

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

inlineinherited

Reset()

G4bool G4Polycone::Reset

(

)

Definition at line 436 of file G4Polycone.cc.

{
  //
  // Clear old setup
  //
  G4VCSGfaceted::DeleteStuff();
  delete [] corners;
  delete enclosingCylinder;
  delete fElements;
  corners = nullptr;
  fElements = nullptr;
  enclosingCylinder = nullptr;
 
  //
  // Rebuild polycone
  //
  G4ReduciblePolygon *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;
}

References corners, Create(), G4VCSGfaceted::DeleteStuff(), enclosingCylinder, fElements, G4PolyconeHistorical::Num_z_planes, G4PolyconeHistorical::Opening_angle, original_parameters, G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, G4PolyconeHistorical::Start_angle, and G4PolyconeHistorical::Z_values.

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

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().

SetOriginalParameters() [1/2]

void G4Polycone::SetOriginalParameters ( G4PolyconeHistorical *  pars )

inline

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

SetOriginalParameters() [2/2]

G4bool G4Polycone::SetOriginalParameters ( G4ReduciblePolygon *  rz )

protected

Definition at line 961 of file G4Polycone.cc.

{
  G4int numPlanes = numCorner;
  G4bool isConvertible = true;
  G4double Zmax=rz->Bmax();
  rz->StartWithZMin();
 
  // Prepare vectors for storage
  //
  std::vector<G4double> Z;
  std::vector<G4double> Rmin;
  std::vector<G4double> Rmax;
 
  G4int countPlanes=1;
  G4int icurr=0;
  G4int icurl=0;
 
  // first plane Z=Z[0]
  //
  Z.push_back(corners[0].z);
  G4double Zprev=Z[0];
  if (Zprev == corners[1].z)
  {
    Rmin.push_back(corners[0].r);
    Rmax.push_back (corners[1].r);icurr=1;
  }
  else if (Zprev == corners[numPlanes-1].z)
  {
    Rmin.push_back(corners[numPlanes-1].r);
    Rmax.push_back (corners[0].r);
    icurl=numPlanes-1;
  }
  else
  {
    Rmin.push_back(corners[0].r);
    Rmax.push_back (corners[0].r);
  }
 
  // next planes until last
  //
  G4int inextr=0, inextl=0;
  for (G4int i=0; i < numPlanes-2; ++i)
  {
    inextr=1+icurr;
    inextl=(icurl <= 0)? numPlanes-1 : icurl-1;
 
    if((corners[inextr].z >= Zmax) & (corners[inextl].z >= Zmax))  { break; }
 
    G4double Zleft = corners[inextl].z;
    G4double Zright = corners[inextr].z;
    if(Zright > Zleft)  // Next plane will be Zleft
    {
      Z.push_back(Zleft);
      countPlanes++;
      G4double difZr=corners[inextr].z - corners[icurr].z;
      G4double difZl=corners[inextl].z - corners[icurl].z;
 
      if(std::fabs(difZl) < kCarTolerance)
      {
        if(std::fabs(difZr) < kCarTolerance)
        {
          Rmin.push_back(corners[inextl].r);
          Rmax.push_back(corners[icurr].r);
        }
        else
        {
          Rmin.push_back(corners[inextl].r);
          Rmax.push_back(corners[icurr].r + (Zleft-corners[icurr].z)/difZr
                                *(corners[inextr].r - corners[icurr].r));
        }
      }
      else if (difZl >= kCarTolerance)
      {
        if(std::fabs(difZr) < kCarTolerance)
        {
          Rmin.push_back(corners[icurl].r);
          Rmax.push_back(corners[icurr].r);
        }
        else
        {
          Rmin.push_back(corners[icurl].r);
          Rmax.push_back(corners[icurr].r + (Zleft-corners[icurr].z)/difZr
                                *(corners[inextr].r - corners[icurr].r));
        }
      }
      else
      {
        isConvertible=false; break;
      }
      icurl=(icurl == 0)? numPlanes-1 : icurl-1;
    }
    else if(std::fabs(Zright-Zleft)<kCarTolerance)  // Zright=Zleft
    {
      Z.push_back(Zleft);
      ++countPlanes;
      ++icurr;
 
      icurl=(icurl == 0)? numPlanes-1 : icurl-1;
 
      Rmin.push_back(corners[inextl].r);
      Rmax.push_back(corners[inextr].r);
    }
    else  // Zright<Zleft
    {
      Z.push_back(Zright);
      ++countPlanes;
 
      G4double difZr=corners[inextr].z - corners[icurr].z;
      G4double difZl=corners[inextl].z - corners[icurl].z;
      if(std::fabs(difZr) < kCarTolerance)
      {
        if(std::fabs(difZl) < kCarTolerance)
        {
          Rmax.push_back(corners[inextr].r);
          Rmin.push_back(corners[icurr].r);
        }
        else
        {
          Rmin.push_back(corners[icurl].r + (Zright-corners[icurl].z)/difZl
                                *(corners[inextl].r - corners[icurl].r));
          Rmax.push_back(corners[inextr].r);
        }
        ++icurr;
      }           // plate
      else if (difZr >= kCarTolerance)
      {
        if(std::fabs(difZl) < kCarTolerance)
        {
          Rmax.push_back(corners[inextr].r);
          Rmin.push_back (corners[icurr].r);
        }
        else
        {
          Rmax.push_back(corners[inextr].r);
          Rmin.push_back (corners[icurl].r+(Zright-corners[icurl].z)/difZl
                                  * (corners[inextl].r - corners[icurl].r));
        }
        ++icurr;
      }
      else
      {
        isConvertible=false; break;
      }
    }
  }   // end for loop
 
  // last plane Z=Zmax
  //
  Z.push_back(Zmax);
  ++countPlanes;
  inextr=1+icurr;
  inextl=(icurl <= 0)? numPlanes-1 : icurl-1;
 
  Rmax.push_back(corners[inextr].r);
  Rmin.push_back(corners[inextl].r);
 
  // Set original parameters Rmin,Rmax,Z
  //
  if(isConvertible)
  {
   original_parameters = new G4PolyconeHistorical;
   original_parameters->Z_values = new G4double[countPlanes];
   original_parameters->Rmin = new G4double[countPlanes];
   original_parameters->Rmax = new G4double[countPlanes];
 
   for(G4int j=0; j < countPlanes; ++j)
   {
     original_parameters->Z_values[j] = Z[j];
     original_parameters->Rmax[j] = Rmax[j];
     original_parameters->Rmin[j] = Rmin[j];
   }
   original_parameters->Start_angle = startPhi;
   original_parameters->Opening_angle = endPhi-startPhi;
   original_parameters->Num_z_planes = countPlanes;
 
  }
  else  // Set parameters(r,z) with Rmin==0 as convention
  {
#ifdef G4SPECSDEBUG
    std::ostringstream message;
    message << "Polycone " << GetName() << G4endl
            << "cannot be converted to Polycone with (Rmin,Rmaz,Z) parameters!";
    G4Exception("G4Polycone::SetOriginalParameters()", "GeomSolids0002",
                JustWarning, message);
#endif
    original_parameters = new G4PolyconeHistorical;
    original_parameters->Z_values = new G4double[numPlanes];
    original_parameters->Rmin = new G4double[numPlanes];
    original_parameters->Rmax = new G4double[numPlanes];
 
    for(G4int j=0; j < numPlanes; ++j)
    {
      original_parameters->Z_values[j] = corners[j].z;
      original_parameters->Rmax[j] = corners[j].r;
      original_parameters->Rmin[j] = 0.0;
    }
    original_parameters->Start_angle = startPhi;
    original_parameters->Opening_angle = endPhi-startPhi;
    original_parameters->Num_z_planes = numPlanes;
  }
  return isConvertible;
}

References G4ReduciblePolygon::Bmax(), corners, endPhi, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, G4VSolid::kCarTolerance, G4PolyconeHistorical::Num_z_planes, numCorner, G4PolyconeHistorical::Opening_angle, original_parameters, G4PolyconeSideRZ::r, G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, G4PolyconeHistorical::Start_angle, startPhi, G4ReduciblePolygon::StartWithZMin(), G4PolyconeSideRZ::z, Z, and G4PolyconeHistorical::Z_values.

SetSurfaceElements()

void G4Polycone::SetSurfaceElements ( ) const

protected

Definition at line 823 of file G4Polycone.cc.

{
  fElements = new std::vector<G4Polycone::surface_element>;
  G4double total = 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);
    G4Polycone::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));
    total += 0.5*dphi*(b.r + a.r)*h;
    selem.area = total;
    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)
    {
      G4Polycone::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));
      total += stria;
      selem.area = total;
      fElements->push_back(selem); // start phi
      total += stria;
      selem.area = total;
      selem.i0 += nrz;
      fElements->push_back(selem); // end phi
    }
  }
}

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

Referenced by GetPointOnSurface().

StreamInfo()

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

virtual

Reimplemented from G4VCSGfaceted.

Definition at line 712 of file G4Polycone.cc.

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

References corners, degree, endPhi, G4VSolid::GetName(), G4PolyconeHistorical::Num_z_planes, numCorner, original_parameters, G4PolyconeSideRZ::r, G4PolyconeHistorical::Rmax, G4PolyconeHistorical::Rmin, startPhi, G4PolyconeSideRZ::z, and G4PolyconeHistorical::Z_values.

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* G4Polycone::corners = nullptr

protected

Definition at line 177 of file G4Polycone.hh.

Referenced by CopyStuff(), Create(), CreatePolyhedron(), operator=(), Reset(), SetOriginalParameters(), StreamInfo(), and ~G4Polycone().

enclosingCylinder

G4EnclosingCylinder* G4Polycone::enclosingCylinder = nullptr

protected

Definition at line 180 of file G4Polycone.hh.

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

endPhi

G4double G4Polycone::endPhi

protected

Definition at line 174 of file G4Polycone.hh.

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

faces

G4VCSGface** G4VCSGfaceted::faces = nullptr

protectedinherited

Definition at line 110 of file G4VCSGfaceted.hh.

Referenced by G4VCSGfaceted::CalculateExtent(), G4VCSGfaceted::CopyStuff(), G4Polyhedra::Create(), G4GenericPolycone::Create(), 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(), G4GenericPolycone::GetCubicVolume(), 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>* G4Polycone::fElements = nullptr

mutableprotected

Definition at line 183 of file G4Polycone.hh.

Referenced by CopyStuff(), GetPointOnSurface(), Reset(), SetSurfaceElements(), and ~G4Polycone().

fpPolyhedron

G4Polyhedron* G4VCSGfaceted::fpPolyhedron = nullptr

mutableprotectedinherited

Definition at line 114 of file G4VCSGfaceted.hh.

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

fRebuildPolyhedron

G4bool G4VCSGfaceted::fRebuildPolyhedron = false

mutableprotectedinherited

Definition at line 113 of file G4VCSGfaceted.hh.

Referenced by G4GenericPolycone::CopyStuff(), 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(), G4GenericPolycone::GetSurfaceArea(), 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(), CalculateExtent(), G4Polyhedra::CalculateExtent(), G4Tet::CheckDegeneracy(), G4Para::CheckParameters(), G4Trd::CheckParameters(), G4Ellipsoid::CheckParameters(), G4EllipticalTube::CheckParameters(), G4GenericTrap::ComputeIsTwisted(), G4Polyhedra::Create(), G4GenericPolycone::Create(), 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(), G4GenericPolycone::GetPointOnSurface(), 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(), SetOriginalParameters(), G4Polyhedra::SetOriginalParameters(), G4Box::SetXHalfLength(), G4Box::SetYHalfLength(), G4Box::SetZHalfLength(), G4Torus::SurfaceNormal(), G4GenericTrap::SurfaceNormal(), and G4Paraboloid::SurfaceNormal().

numCorner

G4int G4Polycone::numCorner

protected

Definition at line 176 of file G4Polycone.hh.

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

numFace

G4int G4VCSGfaceted::numFace = 0

protectedinherited

Definition at line 109 of file G4VCSGfaceted.hh.

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

original_parameters

G4PolyconeHistorical* G4Polycone::original_parameters = nullptr

protected

Definition at line 178 of file G4Polycone.hh.

Referenced by CopyStuff(), G4Polycone(), operator=(), Reset(), SetOriginalParameters(), StreamInfo(), and ~G4Polycone().

phiIsOpen

G4bool G4Polycone::phiIsOpen = false

protected

Definition at line 175 of file G4Polycone.hh.

Referenced by CopyStuff(), and Create().

startPhi

G4double G4Polycone::startPhi

protected

Definition at line 173 of file G4Polycone.hh.

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

---

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

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