G4VCSGfaceted Class Reference

G4VCSGfaceted is a virtual class defining a CSG-like type shape that is built entirely of G4CSGface faces. More...

#include <G4VCSGfaceted.hh>

Inheritance diagram for G4VCSGfaceted:

Public Member Functions
	G4VCSGfaceted (const G4String &name)
	~G4VCSGfaceted () override
	G4VCSGfaceted (const G4VCSGfaceted &source)
G4VCSGfaceted &	operator= (const G4VCSGfaceted &source)
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
G4GeometryType	GetEntityType () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4Polyhedron *	CreatePolyhedron () const override=0
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4Polyhedron *	GetPolyhedron () const override
G4int	GetCubVolStatistics () const
G4double	GetCubVolEpsilon () const
void	SetCubVolStatistics (G4int st)
void	SetCubVolEpsilon (G4double ep)
G4int	GetAreaStatistics () const
G4double	GetAreaAccuracy () const
void	SetAreaStatistics (G4int st)
void	SetAreaAccuracy (G4double ep)
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
	G4VCSGfaceted (__void__ &)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
virtual void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4int	GetNumOfConstituents () const
virtual G4bool	IsFaceted () const
virtual G4VSolid *	Clone () const
void	DumpInfo () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Protected Member Functions
virtual G4double	DistanceTo (const G4ThreeVector &p, const G4bool outgoing) const
G4ThreeVector	GetPointOnSurfaceGeneric () const
void	CopyStuff (const G4VCSGfaceted &source)
void	DeleteStuff ()
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const

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

Detailed Description

G4VCSGfaceted is a virtual class defining a CSG-like type shape that is built entirely of G4CSGface faces.

Definition at line 48 of file G4VCSGfaceted.hh.

Constructor & Destructor Documentation

G4VCSGfaceted() [1/3]

G4VCSGfaceted::G4VCSGfaceted

(

const G4String &

name

)

Constructor taking a 'name'.

Definition at line 56 of file G4VCSGfaceted.cc.

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

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

~G4VCSGfaceted()

G4VCSGfaceted::~G4VCSGfaceted ( )

override

Destructor.

Definition at line 76 of file G4VCSGfaceted.cc.

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

G4VCSGfaceted() [2/3]

G4VCSGfaceted::G4VCSGfaceted

(

const G4VCSGfaceted &

source

)

Copy constructor and assignment operator.

Definition at line 86 of file G4VCSGfaceted.cc.

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

G4VCSGfaceted() [3/3]

G4VCSGfaceted::G4VCSGfaceted

(

__void__ &

a

)

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

Definition at line 67 of file G4VCSGfaceted.cc.

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

Member Function Documentation

CalculateExtent()

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

overridevirtual

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

Parameters

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

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

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

CopyStuff()

void G4VCSGfaceted::CopyStuff ( const G4VCSGfaceted & source )

protected

Copy parameters from other solid or reset them. Used in copy constructor and assignment operator.

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

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

CreatePolyhedron()

G4Polyhedron * G4VCSGfaceted::CreatePolyhedron ( ) const

overridepure virtual

Returns a pointer to a generated polyhedron used for visualisation.

Reimplemented from G4VSolid.

Implemented in G4GenericPolycone, G4Polycone, and G4Polyhedra.

Referenced by GetPolyhedron().

DeleteStuff()

void G4VCSGfaceted::DeleteStuff ( )

protected

Definition at line 151 of file G4VCSGfaceted.cc.

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

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

DescribeYourselfTo()

void G4VCSGfaceted::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 397 of file G4VCSGfaceted.cc.

{
   scene.AddSolid( *this );
}

DistanceTo()

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

protectedvirtual

Protected method used in DistanceToIn() and DistanceToOut().

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

Referenced by DistanceToIn(), and DistanceToOut().

DistanceToIn() [1/2]

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

overridevirtual

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

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to enter the shape.

Implements G4VSolid.

Definition at line 291 of file G4VCSGfaceted.cc.

{
  return DistanceTo( p, false );
}

DistanceToIn() [2/2]

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

overridevirtual

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

Parameters

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

Returns

The distance to enter the shape.

Implements G4VSolid.

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

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

DistanceToOut() [1/2]

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

overridevirtual

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

Parameters

[in]

p

The point at offset p.

Returns

The safety distance to exit the shape.

Implements G4VSolid.

Definition at line 368 of file G4VCSGfaceted.cc.

{
  return DistanceTo( p, true );
}

DistanceToOut() [2/2]

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

overridevirtual

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

Parameters

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

Returns

The distance to exit the shape.

Implements G4VSolid.

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

GetAreaAccuracy()

G4double G4VCSGfaceted::GetAreaAccuracy

(

)

const

Definition at line 515 of file G4VCSGfaceted.cc.

{
  return fAreaAccuracy;
}

GetAreaStatistics()

G4int G4VCSGfaceted::GetAreaStatistics

(

)

const

Definition at line 506 of file G4VCSGfaceted.cc.

{
  return fStatistics;
}

GetCubicVolume()

G4double G4VCSGfaceted::GetCubicVolume ( )

overridevirtual

Returning an estimation of the solid volume (capacity) and surface area, in internal units. Caches the computed value once computed the first time.

Reimplemented from G4VSolid.

Definition at line 544 of file G4VCSGfaceted.cc.

{
  if (fCubicVolume == 0)
  {
    G4AutoLock l(&vcsgMutex);
    fCubicVolume = EstimateCubicVolume(fStatistics,fCubVolEpsilon);
    l.unlock();
  }
  return fCubicVolume;
}

GetCubVolEpsilon()

G4double G4VCSGfaceted::GetCubVolEpsilon

(

)

const

Definition at line 477 of file G4VCSGfaceted.cc.

{
  return fCubVolEpsilon;
}

GetCubVolStatistics()

G4int G4VCSGfaceted::GetCubVolStatistics

(

)

const

Accessors and modifiers for capacity and area computation.

Definition at line 468 of file G4VCSGfaceted.cc.

{
  return fStatistics;
}

GetEntityType()

G4GeometryType G4VCSGfaceted::GetEntityType ( ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 442 of file G4VCSGfaceted.cc.

{
  return {"G4CSGfaceted"};
}

GetExtent()

G4VisExtent G4VCSGfaceted::GetExtent ( ) const

overridevirtual

Provides extent (bounding box) as possible hint to the graphics view.

Reimplemented from G4VSolid.

Definition at line 408 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 { -answers[0], answers[1], 
           -answers[2], answers[3],
           -answers[4], answers[5]  };
}

GetPointOnSurfaceGeneric()

G4ThreeVector G4VCSGfaceted::GetPointOnSurfaceGeneric ( ) const

protected

Returns a random point located on the surface of the solid in case of generic Polycone or generic Polyhedra.

Definition at line 595 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*G4QuickRand();
  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;
}

GetPolyhedron()

G4Polyhedron * G4VCSGfaceted::GetPolyhedron ( ) const

overridevirtual

Smart access function - creates on request and stores for future access. A null pointer means "not available".

Reimplemented from G4VSolid.

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

GetSurfaceArea()

G4double G4VCSGfaceted::GetSurfaceArea ( )

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 559 of file G4VCSGfaceted.cc.

{
  if (fSurfaceArea == 0)
  {
    G4AutoLock l(&vcsgMutex);
    fSurfaceArea = EstimateSurfaceArea(fStatistics,fAreaAccuracy);
    l.unlock();
  }
  return fSurfaceArea;
}

Inside()

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

overridevirtual

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

Implements G4VSolid.

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

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

operator=()

G4VCSGfaceted & G4VCSGfaceted::operator=

(

const G4VCSGfaceted &

source

)

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

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

SetAreaAccuracy()

void G4VCSGfaceted::SetAreaAccuracy

(

G4double

ep

)

Definition at line 534 of file G4VCSGfaceted.cc.

{
  fSurfaceArea=0.;
  fAreaAccuracy=ep;
}

SetAreaStatistics()

void G4VCSGfaceted::SetAreaStatistics

(

G4int

st

)

Definition at line 524 of file G4VCSGfaceted.cc.

{
  fSurfaceArea=0.;
  fStatistics=st;
}

SetCubVolEpsilon()

void G4VCSGfaceted::SetCubVolEpsilon

(

G4double

ep

)

Definition at line 496 of file G4VCSGfaceted.cc.

{
  fCubicVolume=0.;
  fCubVolEpsilon=ep;
}

SetCubVolStatistics()

void G4VCSGfaceted::SetCubVolStatistics

(

G4int

st

)

Definition at line 486 of file G4VCSGfaceted.cc.

{
  fCubicVolume=0.;
  fStatistics=st;
}

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

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

SurfaceNormal()

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

overridevirtual

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

Parameters

[in]

p

The point at offset p.

Returns

The outwards pointing unit normal.

Implements G4VSolid.

Definition at line 226 of file G4VCSGfaceted.cc.

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

Member Data Documentation

faces

G4VCSGface** G4VCSGfaceted::faces = nullptr

protected

Definition at line 172 of file G4VCSGfaceted.hh.

Referenced by CalculateExtent(), CopyStuff(), DeleteStuff(), DistanceTo(), DistanceToIn(), DistanceToOut(), GetExtent(), GetPointOnSurfaceGeneric(), Inside(), and SurfaceNormal().

fCubicVolume

G4double G4VCSGfaceted::fCubicVolume = 0.0

protected

Definition at line 173 of file G4VCSGfaceted.hh.

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

fpPolyhedron

G4Polyhedron* G4VCSGfaceted::fpPolyhedron = nullptr

mutableprotected

Definition at line 176 of file G4VCSGfaceted.hh.

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

fRebuildPolyhedron

G4bool G4VCSGfaceted::fRebuildPolyhedron = false

mutableprotected

Definition at line 175 of file G4VCSGfaceted.hh.

Referenced by CopyStuff(), and GetPolyhedron().

fSurfaceArea

G4double G4VCSGfaceted::fSurfaceArea = 0.0

protected

Definition at line 174 of file G4VCSGfaceted.hh.

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

numFace

G4int G4VCSGfaceted::numFace = 0

protected

Definition at line 171 of file G4VCSGfaceted.hh.

Referenced by CalculateExtent(), CopyStuff(), DeleteStuff(), DistanceTo(), DistanceToIn(), DistanceToOut(), GetExtent(), GetPointOnSurfaceGeneric(), Inside(), StreamInfo(), and SurfaceNormal().

---

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

• G4VCSGfaceted.hh
• G4VCSGfaceted.cc