G4VCSGfaceted Class Reference

#include <G4VCSGfaceted.hh>

Inheritance diagram for G4VCSGfaceted:

Public Member Functions
virtual void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const
virtual G4VSolid *	Clone () const
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4Polyhedron *	CreatePolyhedron () const =0
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const
virtual G4double	DistanceToIn (const G4ThreeVector &p) const
virtual 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
	G4VCSGfaceted (__void__ &)
	G4VCSGfaceted (const G4String &name)
	G4VCSGfaceted (const G4VCSGfaceted &source)
G4double	GetAreaAccuracy () const
G4int	GetAreaStatistics () const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4double	GetCubicVolume ()
G4double	GetCubVolEpsilon () const
G4int	GetCubVolStatistics () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4GeometryType	GetEntityType () const
virtual G4VisExtent	GetExtent () const
G4String	GetName () const
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4Polyhedron *	GetPolyhedron () const
virtual G4double	GetSurfaceArea ()
G4double	GetTolerance () const
virtual EInside	Inside (const G4ThreeVector &p) const
G4VCSGfaceted &	operator= (const G4VCSGfaceted &source)
G4bool	operator== (const G4VSolid &s) const
void	SetAreaAccuracy (G4double ep)
void	SetAreaStatistics (G4int st)
void	SetCubVolEpsilon (G4double ep)
void	SetCubVolStatistics (G4int st)
void	SetName (const G4String &name)
virtual std::ostream &	StreamInfo (std::ostream &os) const
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const
virtual	~G4VCSGfaceted ()

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 G4VCSGfaceted &source)
void	DeleteStuff ()
virtual G4double	DistanceTo (const G4ThreeVector &p, const G4bool outgoing) const
G4ThreeVector	GetPointOnSurfaceGeneric () const

Protected Attributes
G4VCSGface **	faces = nullptr
G4double	fCubicVolume = 0.0
G4Polyhedron *	fpPolyhedron = nullptr
G4bool	fRebuildPolyhedron = false
G4double	fSurfaceArea = 0.0
G4double	kCarTolerance
G4int	numFace = 0

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 43 of file G4VCSGfaceted.hh.

Constructor & Destructor Documentation

G4VCSGfaceted() [1/3]

G4VCSGfaceted::G4VCSGfaceted

(

const G4String &

name

)

Definition at line 55 of file G4VCSGfaceted.cc.

  : G4VSolid(name),
    fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.)
{
}

~G4VCSGfaceted()

G4VCSGfaceted::~G4VCSGfaceted ( )

virtual

Definition at line 75 of file G4VCSGfaceted.cc.

{
  DeleteStuff();
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

References DeleteStuff(), and fpPolyhedron.

G4VCSGfaceted() [2/3]

G4VCSGfaceted::G4VCSGfaceted

(

const G4VCSGfaceted &

source

)

Definition at line 85 of file G4VCSGfaceted.cc.

  : G4VSolid( source )
{
  fStatistics = source.fStatistics;
  fCubVolEpsilon = source.fCubVolEpsilon;
  fAreaAccuracy = source.fAreaAccuracy;
 
  CopyStuff( source );
}

References CopyStuff(), fAreaAccuracy, fCubVolEpsilon, and fStatistics.

G4VCSGfaceted() [3/3]

G4VCSGfaceted::G4VCSGfaceted

(

__void__ &

a

)

Definition at line 66 of file G4VCSGfaceted.cc.

  : G4VSolid(a),
    fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.)
{
}

Member Function Documentation

BoundingLimits()

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

virtualinherited

Reimplemented in G4MultiUnion, G4ReflectedSolid, G4DisplacedSolid, G4IntersectionSolid, G4ScaledSolid, G4SubtractionSolid, G4UnionSolid, G4Box, G4Cons, G4CutTubs, G4Orb, G4Para, G4Sphere, G4Torus, G4Trap, G4Trd, G4Tubs, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4Paraboloid, G4Polycone, G4Polyhedra, G4TessellatedSolid, G4Tet, G4TwistedTubs, and G4VTwistedFaceted.

Definition at line 665 of file G4VSolid.cc.

{
  std::ostringstream message;
  message << "Not implemented for solid: "
          << GetEntityType() << " !"
          << "\nReturning infinite boundinx box.";
  G4Exception("G4VSolid::BoundingLimits()", "GeomMgt1001",
              JustWarning, message);
 
  pMin.set(-kInfinity,-kInfinity,-kInfinity);
  pMax.set( kInfinity, kInfinity, kInfinity);
}

References G4Exception(), G4VSolid::GetEntityType(), JustWarning, kInfinity, pMax, and pMin.

Referenced by G4ReflectedSolid::BoundingLimits(), G4DisplacedSolid::BoundingLimits(), G4IntersectionSolid::BoundingLimits(), G4ScaledSolid::BoundingLimits(), G4SubtractionSolid::BoundingLimits(), G4UnionSolid::BoundingLimits(), G4Voxelizer::BuildVoxelLimits(), G4ScaledSolid::CalculateExtent(), G4PVPlacement::CheckOverlaps(), G4VSolid::EstimateSurfaceArea(), G4MultiUnion::Extent(), G4SubtractionSolid::GetCubicVolume(), and G4UnionSolid::GetCubicVolume().

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

virtual

Implements G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 169 of file G4VCSGfaceted.cc.

{
  G4SolidExtentList  extentList( axis, voxelLimit );
 
  //
  // Loop over all faces, checking min/max extent as we go.
  //
  G4VCSGface **face = faces;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    (*face)->CalculateExtent( axis, voxelLimit, transform, extentList );
  } while( ++face < faces + numFace );
  
  //
  // Return min/max value
  //
  return extentList.GetExtent( min, max );
}

References G4VCSGface::CalculateExtent(), faces, G4SolidExtentList::GetExtent(), G4INCL::Math::max(), G4INCL::Math::min(), numFace, and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

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 * G4VSolid::Clone ( ) const

virtualinherited

Reimplemented in G4ReflectedSolid, G4DisplacedSolid, G4IntersectionSolid, G4MultiUnion, G4ScaledSolid, G4SubtractionSolid, G4UnionSolid, G4Box, G4Cons, G4CutTubs, G4Orb, G4Para, G4Sphere, G4Torus, G4Trap, G4Trd, G4Tubs, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4ExtrudedSolid, G4GenericPolycone, G4GenericTrap, G4Hype, G4Paraboloid, G4Polycone, G4Polyhedra, G4TessellatedSolid, G4Tet, G4TwistedBox, G4TwistedTrap, G4TwistedTrd, and G4TwistedTubs.

Definition at line 391 of file G4VSolid.cc.

{
  std::ostringstream message;
  message << "Clone() method not implemented for type: "
          << GetEntityType() << "!" << G4endl
          << "Returning NULL pointer!";
  G4Exception("G4VSolid::Clone()", "GeomMgt1001", JustWarning, message);
  return nullptr;
}

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

Referenced by G4GeometryWorkspace::CloneReplicaSolid().

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

void G4VCSGfaceted::CopyStuff ( const G4VCSGfaceted &  source )

protected

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(), faces, fCubicVolume, fpPolyhedron, fRebuildPolyhedron, fSurfaceArea, and numFace.

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

CreatePolyhedron()

virtual G4Polyhedron * G4VCSGfaceted::CreatePolyhedron ( ) const

pure virtual

Reimplemented from G4VSolid.

Implemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Referenced by GetPolyhedron().

DeleteStuff()

void G4VCSGfaceted::DeleteStuff ( )

protected

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 faces, fpPolyhedron, and numFace.

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

DescribeYourselfTo()

void G4VCSGfaceted::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

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

protectedvirtual

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 faces, G4VSolid::kCarTolerance, kInfinity, and numFace.

Referenced by DistanceToIn(), and DistanceToOut().

DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 290 of file G4VCSGfaceted.cc.

{
  return DistanceTo( p, false );
}

References DistanceTo().

DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 248 of file G4VCSGfaceted.cc.

{
  G4double distance = kInfinity;
  G4double distFromSurface = kInfinity;
  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, false, kCarTolerance/2,
                faceDistance, faceDistFromSurface,
                faceNormal, faceAllBehind ) )
    {
      //
      // Intersecting face
      //
      if (faceDistance < distance)
      {
        distance = faceDistance;
        distFromSurface = faceDistFromSurface;
        bestFace = *face;
        if (distFromSurface <= 0) { return 0; }
      }
    }
  } while( ++face < faces + numFace );
  
  if (distance < kInfinity && distFromSurface<kCarTolerance/2)
  {
    if (bestFace->Distance(p,false) < kCarTolerance/2)  { distance = 0; }
  }
 
  return distance;
}

References G4VCSGface::Distance(), faces, G4VSolid::kCarTolerance, kInfinity, and numFace.

Referenced by G4GenericPolycone::DistanceToIn(), G4Polycone::DistanceToIn(), and G4Polyhedra::DistanceToIn().

DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 367 of file G4VCSGfaceted.cc.

{
  return DistanceTo( p, true );
}

References DistanceTo().

DistanceToOut() [2/2]

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

virtual

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(), faces, Inside(), G4VSolid::kCarTolerance, kInfinity, kSurface, CLHEP::detail::n, CLHEP::normal(), and 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(), 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 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 GetSurfaceArea().

GetAreaAccuracy()

G4double G4VCSGfaceted::GetAreaAccuracy

(

)

const

Definition at line 514 of file G4VCSGfaceted.cc.

{
  return fAreaAccuracy;
}

References fAreaAccuracy.

GetAreaStatistics()

G4int G4VCSGfaceted::GetAreaStatistics

(

)

const

Definition at line 505 of file G4VCSGfaceted.cc.

{
  return fStatistics;
}

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

GetCubicVolume()

G4double G4VCSGfaceted::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 543 of file G4VCSGfaceted.cc.

{
  if(fCubicVolume != 0.) {;}
  else   { fCubicVolume = EstimateCubicVolume(fStatistics,fCubVolEpsilon); }
  return fCubicVolume;
}

References G4VSolid::EstimateCubicVolume(), fCubicVolume, fCubVolEpsilon, and fStatistics.

GetCubVolEpsilon()

G4double G4VCSGfaceted::GetCubVolEpsilon

(

)

const

Definition at line 476 of file G4VCSGfaceted.cc.

{
  return fCubVolEpsilon;
}

References fCubVolEpsilon.

GetCubVolStatistics()

G4int G4VCSGfaceted::GetCubVolStatistics

(

)

const

Definition at line 467 of file G4VCSGfaceted.cc.

{
  return fStatistics;
}

References 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; }

GetEntityType()

G4GeometryType G4VCSGfaceted::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 441 of file G4VCSGfaceted.cc.

{
  return G4String("G4CSGfaceted");
}

GetExtent()

G4VisExtent G4VCSGfaceted::GetExtent ( ) const

virtual

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 faces, kInfinity, and 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(), G4Polycone::BoundingLimits(), G4Polyhedra::BoundingLimits(), G4TessellatedSolid::BoundingLimits(), G4TwistedTubs::BoundingLimits(), G4GDMLWriteSolids::BoxWrite(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::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(), G4GenericPolycone::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(), G4GenericPolycone::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(), G4GenericPolycone::StreamInfo(), G4GenericTrap::StreamInfo(), G4Hype::StreamInfo(), G4Paraboloid::StreamInfo(), G4Polycone::StreamInfo(), G4Polyhedra::StreamInfo(), G4TessellatedSolid::StreamInfo(), G4Tet::StreamInfo(), G4TwistedBox::StreamInfo(), G4TwistedTrap::StreamInfo(), G4TwistedTrd::StreamInfo(), G4TwistedTubs::StreamInfo(), 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().

GetPointOnSurface()

G4ThreeVector G4VSolid::GetPointOnSurface ( ) const

virtualinherited

Reimplemented in G4ReflectedSolid, G4BooleanSolid, G4DisplacedSolid, G4MultiUnion, G4ScaledSolid, G4Box, G4Cons, G4CutTubs, G4Orb, G4Para, G4Sphere, G4Torus, G4Trap, G4Trd, G4Tubs, G4Ellipsoid, G4EllipticalCone, G4EllipticalTube, G4GenericPolycone, G4GenericTrap, G4Hype, G4Paraboloid, G4Polycone, G4Polyhedra, G4TessellatedSolid, G4Tet, G4TwistedTubs, and G4VTwistedFaceted.

Definition at line 152 of file G4VSolid.cc.

{
    std::ostringstream message;
    message << "Not implemented for solid: "
            << GetEntityType() << " !" << G4endl
            << "Returning origin.";
    G4Exception("G4VSolid::GetPointOnSurface()", "GeomMgt1001",
                JustWarning, message);
    return G4ThreeVector(0,0,0);
}

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

Referenced by G4PVParameterised::CheckOverlaps(), G4PVPlacement::CheckOverlaps(), G4LogicalVolumeModel::DescribeYourselfTo(), export_G4VSolid(), G4ReflectedSolid::GetPointOnSurface(), G4DisplacedSolid::GetPointOnSurface(), G4MultiUnion::GetPointOnSurface(), G4ScaledSolid::GetPointOnSurface(), and G4VSceneHandler::RequestPrimitives().

GetPointOnSurfaceGeneric()

G4ThreeVector G4VCSGfaceted::GetPointOnSurfaceGeneric ( ) const

protected

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 faces, G4UniformRand, numFace, and G4VCSGface::SurfaceArea().

GetPolyhedron()

G4Polyhedron * G4VCSGfaceted::GetPolyhedron ( ) const

virtual

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 CreatePolyhedron(), fpPolyhedron, fRebuildPolyhedron, HepPolyhedron::GetNumberOfRotationSteps(), G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation(), anonymous_namespace{G4VCSGfaceted.cc}::polyhedronMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

GetSurfaceArea()

G4double G4VCSGfaceted::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 554 of file G4VCSGfaceted.cc.

{
  if(fSurfaceArea != 0.) {;}
  else   { fSurfaceArea = EstimateSurfaceArea(fStatistics,fAreaAccuracy); }
  return fSurfaceArea;
}

References G4VSolid::EstimateSurfaceArea(), fAreaAccuracy, fStatistics, and fSurfaceArea.

GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

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

Inside()

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

virtual

Implements G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 201 of file G4VCSGfaceted.cc.

{
  EInside answer=kOutside;
  G4VCSGface **face = faces;
  G4double best = kInfinity;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double distance;
    EInside result = (*face)->Inside( p, kCarTolerance/2, &distance );
    if (result == kSurface) { return kSurface; }
    if (distance < best)
    {
      best = distance;
      answer = result;
    }
  } while( ++face < faces + numFace );
 
  return answer;
}

References faces, G4VSolid::kCarTolerance, kInfinity, kOutside, kSurface, and numFace.

Referenced by DistanceToOut(), G4GenericPolycone::Inside(), G4Polycone::Inside(), and G4Polyhedra::Inside().

operator=()

G4VCSGfaceted & G4VCSGfaceted::operator=

(

const G4VCSGfaceted &

source

)

Definition at line 99 of file G4VCSGfaceted.cc.

{
  if (&source == this) { return *this; }
  
  // Copy base class data
  //
  G4VSolid::operator=(source);
 
  // Copy data
  //
  fStatistics = source.fStatistics;
  fCubVolEpsilon = source.fCubVolEpsilon;
  fAreaAccuracy = source.fAreaAccuracy;
 
  DeleteStuff();
  CopyStuff( source );
  
  return *this;
}

References CopyStuff(), DeleteStuff(), fAreaAccuracy, fCubVolEpsilon, fStatistics, and G4VSolid::operator=().

Referenced by G4GenericPolycone::operator=(), G4Polycone::operator=(), and G4Polyhedra::operator=().

operator==()

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

inlineinherited

SetAreaAccuracy()

void G4VCSGfaceted::SetAreaAccuracy

(

G4double

ep

)

Definition at line 533 of file G4VCSGfaceted.cc.

{
  fSurfaceArea=0.;
  fAreaAccuracy=ep;
}

References fAreaAccuracy, and fSurfaceArea.

SetAreaStatistics()

void G4VCSGfaceted::SetAreaStatistics

(

G4int

st

)

Definition at line 523 of file G4VCSGfaceted.cc.

{
  fSurfaceArea=0.;
  fStatistics=st;
}

References fStatistics, and fSurfaceArea.

SetCubVolEpsilon()

void G4VCSGfaceted::SetCubVolEpsilon

(

G4double

ep

)

Definition at line 495 of file G4VCSGfaceted.cc.

{
  fCubicVolume=0.;
  fCubVolEpsilon=ep;
}

References fCubicVolume, and fCubVolEpsilon.

SetCubVolStatistics()

void G4VCSGfaceted::SetCubVolStatistics

(

G4int

st

)

Definition at line 485 of file G4VCSGfaceted.cc.

{
  fCubicVolume=0.;
  fStatistics=st;
}

References fCubicVolume, and 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().

StreamInfo()

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

virtual

Implements G4VSolid.

Reimplemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Definition at line 450 of file G4VCSGfaceted.cc.

{
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: G4VCSGfaceted\n"
     << " Parameters: \n"
     << "    number of faces: " << numFace << "\n"
     << "-----------------------------------------------------------\n";
 
  return os;
}

References G4VSolid::GetName(), and numFace.

SurfaceNormal()

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

virtual

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 faces, kInfinity, CLHEP::normal(), and numFace.

Field Documentation

faces

G4VCSGface** G4VCSGfaceted::faces = nullptr

protected

Definition at line 110 of file G4VCSGfaceted.hh.

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

fAreaAccuracy

G4double G4VCSGfaceted::fAreaAccuracy

private

Definition at line 130 of file G4VCSGfaceted.hh.

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

fCubicVolume

G4double G4VCSGfaceted::fCubicVolume = 0.0

protected

Definition at line 111 of file G4VCSGfaceted.hh.

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

fCubVolEpsilon

G4double G4VCSGfaceted::fCubVolEpsilon

private

Definition at line 129 of file G4VCSGfaceted.hh.

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

fpPolyhedron

G4Polyhedron* G4VCSGfaceted::fpPolyhedron = nullptr

mutableprotected

Definition at line 114 of file G4VCSGfaceted.hh.

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

fRebuildPolyhedron

G4bool G4VCSGfaceted::fRebuildPolyhedron = false

mutableprotected

Definition at line 113 of file G4VCSGfaceted.hh.

Referenced by G4GenericPolycone::CopyStuff(), G4Polycone::CopyStuff(), G4Polyhedra::CopyStuff(), CopyStuff(), and 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

private

Definition at line 128 of file G4VCSGfaceted.hh.

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

fSurfaceArea

G4double G4VCSGfaceted::fSurfaceArea = 0.0

protected

Definition at line 112 of file G4VCSGfaceted.hh.

Referenced by CopyStuff(), G4GenericPolycone::GetSurfaceArea(), G4Polycone::GetSurfaceArea(), G4Polyhedra::GetSurfaceArea(), GetSurfaceArea(), SetAreaAccuracy(), and 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(), G4GenericPolycone::Create(), G4Polycone::Create(), G4CutTubs::CreatePolyhedron(), G4TessellatedSolid::CreateVertexList(), DistanceTo(), G4Sphere::DistanceToIn(), G4Ellipsoid::DistanceToIn(), G4Hype::DistanceToIn(), G4Paraboloid::DistanceToIn(), DistanceToIn(), G4TessellatedSolid::DistanceToInCore(), G4Cons::DistanceToOut(), G4CutTubs::DistanceToOut(), G4Sphere::DistanceToOut(), G4Torus::DistanceToOut(), G4Tubs::DistanceToOut(), G4GenericTrap::DistanceToOut(), G4Hype::DistanceToOut(), G4Paraboloid::DistanceToOut(), 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(), G4Polycone::GetPointOnSurface(), G4UnionSolid::Init(), G4Orb::Initialize(), G4TessellatedSolid::Initialize(), G4SubtractionSolid::Inside(), G4Hype::Inside(), G4Paraboloid::Inside(), 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().

numFace

G4int G4VCSGfaceted::numFace = 0

protected

Definition at line 109 of file G4VCSGfaceted.hh.

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

---

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

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