G4TessellatedSolid Class Reference

G4TessellatedSolid is a solid defined by a number of facets. It is important that the supplied facets shall form a fully enclose space which is the solid. The facets can be of two types, G4TriangularFacet and G4QuadrangularFacet. More...

#include <G4TessellatedSolid.hh>

Inheritance diagram for G4TessellatedSolid:

Public Member Functions
	G4TessellatedSolid ()
	G4TessellatedSolid (const G4String &name)
	~G4TessellatedSolid () override
	G4TessellatedSolid (__void__ &)
	G4TessellatedSolid (const G4TessellatedSolid &ts)
G4TessellatedSolid &	operator= (const G4TessellatedSolid &right)
G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)
G4bool	AddFacet (G4VFacet *aFacet)
G4VFacet *	GetFacet (G4int i) const
G4int	GetNumberOfFacets () const
G4int	GetFacetIndex (const G4ThreeVector &p) const
G4double	GetMinXExtent () const
G4double	GetMaxXExtent () const
G4double	GetMinYExtent () const
G4double	GetMaxYExtent () const
G4double	GetMinZExtent () const
G4double	GetMaxZExtent () const
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 override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm, G4bool *validNorm, G4ThreeVector *norm) const override
virtual G4bool	Normal (const G4ThreeVector &p, G4ThreeVector &n) const
virtual G4double	SafetyFromOutside (const G4ThreeVector &p, G4bool aAccurate=false) const
virtual G4double	SafetyFromInside (const G4ThreeVector &p, G4bool aAccurate=false) const
G4GeometryType	GetEntityType () const override
G4bool	IsFaceted () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4VSolid *	Clone () const override
G4ThreeVector	GetPointOnSurface () const override
G4double	GetSurfaceArea () override
G4double	GetCubicVolume () override
void	SetSolidClosed (const G4bool t)
G4bool	GetSolidClosed () const
G4int	CheckStructure () const
void	SetMaxVoxels (G4int max)
G4Voxelizer &	GetVoxels ()
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4Polyhedron *	CreatePolyhedron () const override
G4Polyhedron *	GetPolyhedron () const override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4VisExtent	GetExtent () const override
G4int	AllocatedMemoryWithoutVoxels ()
G4int	AllocatedMemory ()
void	DisplayAllocatedMemory ()
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	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4int	GetNumOfConstituents () 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 Attributes
G4double	kCarToleranceHalf
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Additional Inherited Members
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

Detailed Description

G4TessellatedSolid is a solid defined by a number of facets. It is important that the supplied facets shall form a fully enclose space which is the solid. The facets can be of two types, G4TriangularFacet and G4QuadrangularFacet.

Definition at line 135 of file G4TessellatedSolid.hh.

Constructor & Destructor Documentation

G4TessellatedSolid() [1/4]

G4TessellatedSolid::G4TessellatedSolid

(

)

Default Constructor.

Definition at line 86 of file G4TessellatedSolid.cc.

                                        : G4VSolid("dummy")
{
  Initialize();
}

Referenced by Clone(), G4ExtrudedSolid::G4ExtrudedSolid(), G4ExtrudedSolid::G4ExtrudedSolid(), G4ExtrudedSolid::G4ExtrudedSolid(), G4TessellatedSolid(), operator+=(), and operator=().

G4TessellatedSolid() [2/4]

G4TessellatedSolid::G4TessellatedSolid

(

const G4String &

name

)

Constructor with solid's name.

Parameters

[in]

name

The name of the solid.

Definition at line 96 of file G4TessellatedSolid.cc.

  : G4VSolid(name)
{
  Initialize();
}

~G4TessellatedSolid()

G4TessellatedSolid::~G4TessellatedSolid ( )

override

Destructor. Clearing all allocated facets and data.

Definition at line 116 of file G4TessellatedSolid.cc.

{
  DeleteObjects();
}

G4TessellatedSolid() [3/4]

G4TessellatedSolid::G4TessellatedSolid

(

__void__ &

a

)

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

Definition at line 107 of file G4TessellatedSolid.cc.

                                                   : G4VSolid(a)
{
  Initialize();
  fMinExtent.set(0,0,0);
  fMaxExtent.set(0,0,0);
}

G4TessellatedSolid() [4/4]

G4TessellatedSolid::G4TessellatedSolid

(

const G4TessellatedSolid &

ts

)

Copy constructor and assignment operator.

Definition at line 125 of file G4TessellatedSolid.cc.

  : G4VSolid(ts)
{
  Initialize();
 
  CopyObjects(ts);
}

Member Function Documentation

AddFacet()

G4bool G4TessellatedSolid::AddFacet

(

G4VFacet *

aFacet

)

Methods for adding or retrieving a facet given an index.

Definition at line 211 of file G4TessellatedSolid.cc.

{
  // Add the facet to the vector.
  //
  if (fSolidClosed)
  {
    G4Exception("G4TessellatedSolid::AddFacet()", "GeomSolids1002",
                JustWarning, "Attempt to add facets when solid is closed.");
    return false;
  }
  if (aFacet->IsDefined())
  {
    set<G4VertexInfo,G4VertexComparator>::iterator begin
      = fFacetList.begin(), end = fFacetList.end(), pos, it;
    G4ThreeVector p = aFacet->GetCircumcentre();
    G4VertexInfo value;
    value.id = (G4int)fFacetList.size();
    value.mag2 = p.x() + p.y() + p.z();
 
    G4bool found = false;
    if (!OutsideOfExtent(p, kCarTolerance))
    {
      G4double kCarTolerance3 = 3 * kCarTolerance;
      pos = fFacetList.lower_bound(value);
 
      it = pos;
      while (!found && it != end)    // Loop checking, 13.08.2015, G.Cosmo
      {
        G4int id = (*it).id;
        G4VFacet *facet = fFacets[id];
        G4ThreeVector q = facet->GetCircumcentre();
        if ((found = (facet == aFacet))) { break; }
        G4double dif = q.x() + q.y() + q.z() - value.mag2;
        if (dif > kCarTolerance3) { break; }
        it++;
      }
 
      if (fFacets.size() > 1)
      {
        it = pos;
        while (!found && it != begin)    // Loop checking, 13.08.2015, G.Cosmo
        {
          --it;
          G4int id = (*it).id;
          G4VFacet *facet = fFacets[id];
          G4ThreeVector q = facet->GetCircumcentre();
          found = (facet == aFacet);
          if (found) { break; }
          G4double dif = value.mag2 - (q.x() + q.y() + q.z());
          if (dif > kCarTolerance3) { break; }
        }
      }
    }
 
    if (!found)
    {
      fFacets.push_back(aFacet);
      fFacetList.insert(value);
    }
    return true;
  }
  
  G4Exception("G4TessellatedSolid::AddFacet()", "GeomSolids1002",
              JustWarning, "Attempt to add facet not properly defined.");
  aFacet->StreamInfo(G4cout);
  return false;
}

Referenced by G4tgbVolume::FindOrConstructG4Solid(), operator+=(), and G4GDMLReadSolids::TessellatedRead().

AllocatedMemory()

G4int G4TessellatedSolid::AllocatedMemory

(

)

Definition at line 2293 of file G4TessellatedSolid.cc.

{
  G4int size = AllocatedMemoryWithoutVoxels();
  G4int sizeInsides = fInsides.GetNbytes();
  G4int sizeVoxels = fVoxels.AllocatedMemory();
  size += sizeInsides + sizeVoxels;
  return size;
}

Referenced by DisplayAllocatedMemory().

AllocatedMemoryWithoutVoxels()

G4int G4TessellatedSolid::AllocatedMemoryWithoutVoxels

(

)

Loggers reporting the total allocated memory.

Definition at line 2270 of file G4TessellatedSolid.cc.

{
  G4int base = sizeof(*this);
  base += fVertexList.capacity() * sizeof(G4ThreeVector);
  base += fRandir.capacity() * sizeof(G4ThreeVector);
 
  std::size_t limit = fFacets.size();
  for (std::size_t i = 0; i < limit; ++i)
  {
    G4VFacet& facet = *fFacets[i];
    base += facet.AllocatedMemory();
  }
 
  for (const auto & fExtremeFacet : fExtremeFacets)
  {
    G4VFacet &facet = *fExtremeFacet;
    base += facet.AllocatedMemory();
  }
  return base;
}

Referenced by AllocatedMemory(), and DisplayAllocatedMemory().

BoundingLimits()

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

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 2018 of file G4TessellatedSolid.cc.

{
  pMin = fMinExtent;
  pMax = fMaxExtent;
 
  // 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("G4TessellatedSolid::BoundingLimits()",
                "GeomMgt0001", JustWarning, message);
    DumpInfo();
  }
}

Referenced by CalculateExtent().

CalculateExtent()

G4bool G4TessellatedSolid::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 2044 of file G4TessellatedSolid.cc.

{
  G4ThreeVector bmin, bmax;
 
  // Check bounding box (bbox)
  //
  BoundingLimits(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
 
  // Use simple bounding-box to help in the case of complex meshes
  //
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
 
#if 0
  // Precise extent computation (disabled by default for this shape)
  //
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return (pMin < pMax) ? true : false;
  }
 
  // The extent is calculated as cumulative extent of the pyramids
  // formed by facets and the center of the bounding box.
  //
  G4double eminlim = pVoxelLimit.GetMinExtent(pAxis);
  G4double emaxlim = pVoxelLimit.GetMaxExtent(pAxis);
 
  G4ThreeVectorList base;
  G4ThreeVectorList apex(1);
  std::vector<const G4ThreeVectorList *> pyramid(2);
  pyramid[0] = &base;
  pyramid[1] = &apex;
  apex[0] = (bmin+bmax)*0.5;
 
  // main loop along facets
  pMin =  kInfinity;
  pMax = -kInfinity;
  for (G4int i=0; i<GetNumberOfFacets(); ++i)
  {
    G4VFacet* facet = GetFacet(i);
    if (std::abs((facet->GetSurfaceNormal()).dot(facet->GetVertex(0)-apex[0]))
        < kCarToleranceHalf) { continue; }
 
    G4int nv = facet->GetNumberOfVertices();
    base.resize(nv);
    for (G4int k=0; k<nv; ++k) { base[k] = facet->GetVertex(k); }
 
    G4double emin,emax;
    G4BoundingEnvelope benv(pyramid);
    if (!benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,emin,emax))
    {
      continue;
    }
    if (emin < pMin) { pMin = emin; }
    if (emax > pMax) { pMax = emax; }
    if (eminlim > pMin && emaxlim < pMax) { break; } // max possible extent
  }
  return (pMin < pMax);
#endif
}

CheckStructure()

G4int G4TessellatedSolid::CheckStructure

(

)

const

Checks the structure of the solid.

Returns

A value, sum of the following defect indicators, if any (0 means no defects): 1 - cubic volume is negative, wrong orientation of facets; 2 - some facets have wrong orientation; 4 - holes in the surface.

Definition at line 701 of file G4TessellatedSolid.cc.

{
  G4int nedge = 0;
  std::size_t nface = fFacets.size();
 
  // Calculate volume
  //
  G4double volume = 0.;
  for (std::size_t i = 0; i < nface; ++i)
  {
    G4VFacet& facet = *fFacets[i];
    nedge += facet.GetNumberOfVertices();
    volume += facet.GetArea()*(facet.GetVertex(0).dot(facet.GetSurfaceNormal()));
  }
  auto  ivolume = static_cast<G4int>(volume <= 0.);
 
  // Create sorted vector of edges
  //
  std::vector<int64_t> iedge(nedge);
  G4int kk = 0;
  for (std::size_t i = 0; i < nface; ++i)
  {
    G4VFacet& facet = *fFacets[i];
    G4int nnode = facet.GetNumberOfVertices();
    for (G4int k = 0; k < nnode; ++k)
    {
      int64_t i1 = facet.GetVertexIndex((k == 0) ? nnode - 1 : k - 1);
      int64_t i2 = facet.GetVertexIndex(k);
      auto  inverse = static_cast<int64_t>(i2 > i1);
      if (inverse != 0) { std::swap(i1, i2); }
      iedge[kk++] = i1*1000000000 + i2*2 + inverse;
    }
  }
  std::sort(iedge.begin(), iedge.end());
 
  // Check edges, correct structure should consist of paired edges
  // with different orientation
  //
  G4int iorder = 0;
  G4int ihole = 0;
  G4int i = 0;
  while (i < nedge - 1)
  {
    if (iedge[i + 1] - iedge[i] == 1) // paired edges with different orientation
    {
      i += 2;
    }
    else if (iedge[i + 1] == iedge[i]) // paired edges with the same orientation
    {
      iorder = 2;
      i += 2;
    }
    else // unpaired edge
    {
      ihole = 4;
      i++;
    }
  }
  return ivolume + iorder + ihole;
}

Referenced by SetSolidClosed().

Clone()

G4VSolid * G4TessellatedSolid::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns

A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 1822 of file G4TessellatedSolid.cc.

{
  return new G4TessellatedSolid(*this);
}

CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 1967 of file G4TessellatedSolid.cc.

{
  auto nVertices = (G4int)fVertexList.size();
  auto nFacets = (G4int)fFacets.size();
  auto polyhedron = new G4Polyhedron(nVertices, nFacets);
  for (auto i = 0; i < nVertices; ++i)
  {
    polyhedron->SetVertex(i+1, fVertexList[i]);
  }
 
  for (auto i = 0; i < nFacets; ++i)
  {
    G4VFacet* facet = fFacets[i];
    G4int v[4] = {0};
    G4int n = facet->GetNumberOfVertices();
    if (n > 4) { n = 4; }
    for (auto j = 0; j < n; ++j)
    {
      v[j] = facet->GetVertexIndex(j) + 1;
    }
    polyhedron->SetFacet(i+1, v[0], v[1], v[2], v[3]);
  }
  polyhedron->SetReferences();
 
  return polyhedron;
}

Referenced by GetPolyhedron().

DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

A "double dispatch" function which identifies the solid to the graphics scene for visualization.

Implements G4VSolid.

Definition at line 1960 of file G4TessellatedSolid.cc.

{
  scene.AddSolid (*this);
}

DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory

(

)

Definition at line 611 of file G4TessellatedSolid.cc.

{
  G4int without = AllocatedMemoryWithoutVoxels();
  G4int with = AllocatedMemory();
  G4double ratio = (G4double) with / without;
  G4cout << "G4TessellatedSolid - Allocated memory without voxel overhead "
         << without << "; with " << with << "; ratio: " << ratio << G4endl;
}

Referenced by SetSolidClosed().

DistanceToIn() [1/2]

G4double G4TessellatedSolid::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 1868 of file G4TessellatedSolid.cc.

{
  return SafetyFromOutside(p, false);
}

DistanceToIn() [2/2]

G4double G4TessellatedSolid::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 1875 of file G4TessellatedSolid.cc.

{
  G4double dist = DistanceToInCore(p,v,kInfinity);
#ifdef G4SPECSDEBUG
  if (dist < kInfinity)
  {
    if (Inside(p + dist*v) != kSurface)
    {
      std::ostringstream message;
      message << "Invalid response from facet in solid '" << GetName() << "',"
              << G4endl
              << "at point: " << p <<  "and direction: " << v;
      G4Exception("G4TessellatedSolid::DistanceToIn(p,v)",
                  "GeomSolids1002", JustWarning, message);
    }
  }
#endif
  return dist;
}

Referenced by G4ExtrudedSolid::DistanceToIn(), G4ExtrudedSolid::DistanceToIn(), and SafetyFromInside().

DistanceToOut() [1/2]

G4double G4TessellatedSolid::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 1903 of file G4TessellatedSolid.cc.

{
  return SafetyFromInside(p, false);
}

Referenced by G4ExtrudedSolid::DistanceToOut(), G4ExtrudedSolid::DistanceToOut(), and SafetyFromOutside().

DistanceToOut() [2/2]

G4double G4TessellatedSolid::DistanceToOut ( const G4ThreeVector & p, const G4ThreeVector & v, const G4bool calcNorm, G4bool * validNorm, G4ThreeVector * n ) 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 1926 of file G4TessellatedSolid.cc.

{
  G4ThreeVector n;
  G4bool valid;
 
  G4double dist = DistanceToOutCore(p, v, n, valid);
  if (calcNorm)
  {
    *norm = n;
    *validNorm = valid;
  }
#ifdef G4SPECSDEBUG
  if (dist < kInfinity)
  {
    if (Inside(p + dist*v) != kSurface)
    {
      std::ostringstream message;
      message << "Invalid response from facet in solid '" << GetName() << "',"
              << G4endl
              << "at point: " << p <<  "and direction: " << v;
      G4Exception("G4TessellatedSolid::DistanceToOut(p,v,..)",
                  "GeomSolids1002", JustWarning, message);
    }
  }
#endif
  return dist;
}

GetCubicVolume()

G4double G4TessellatedSolid::GetCubicVolume ( )

overridevirtual

Returns an estimation of the solid volume 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 2161 of file G4TessellatedSolid.cc.

{
  if (fCubicVolume != 0.) { return fCubicVolume; }
 
  // For explanation of the following algorithm see:
  // https://en.wikipedia.org/wiki/Polyhedron#Volume
  // http://wwwf.imperial.ac.uk/~rn/centroid.pdf
 
  G4AutoLock l(&tessMutex);
  std::size_t size = fFacets.size();
  for (std::size_t i = 0; i < size; ++i)
  {
    G4VFacet &facet = *fFacets[i];
    G4double area = facet.GetArea();
    G4ThreeVector unit_normal = facet.GetSurfaceNormal();
    fCubicVolume += area * (facet.GetVertex(0).dot(unit_normal));
  }
  fCubicVolume /= 3.;
  l.unlock();
 
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4TessellatedSolid::GetEntityType ( ) const

overridevirtual

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

Implements G4VSolid.

Definition at line 1783 of file G4TessellatedSolid.cc.

{
  return fGeometryType;
}

GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 2152 of file G4TessellatedSolid.cc.

{
  return { fMinExtent.x(), fMaxExtent.x(),
           fMinExtent.y(), fMaxExtent.y(),
           fMinExtent.z(), fMaxExtent.z() };
}

GetFacet()

G4VFacet * G4TessellatedSolid::GetFacet ( G4int i ) const

inline

Definition at line 476 of file G4TessellatedSolid.hh.

{
  return fFacets[i];
}

Referenced by CalculateExtent(), operator+=(), and G4GDMLWriteSolids::TessellatedWrite().

GetFacetIndex()

G4int G4TessellatedSolid::GetFacetIndex

(

const G4ThreeVector &

p

)

const

Definition at line 1143 of file G4TessellatedSolid.cc.

{
  G4int index = -1;
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    vector<G4int> curVoxel(3);
    fVoxels.GetVoxel(curVoxel, p);
    const vector<G4int> &candidates = fVoxels.GetCandidates(curVoxel);
    if (auto limit = (G4int)candidates.size())
    {
      G4double minDist = kInfinity;
      for(G4int i = 0 ; i < limit ; ++i)
      {
        G4int candidate = candidates[i];
        G4VFacet& facet = *fFacets[candidate];
        G4double dist = facet.Distance(p, minDist);
        if (dist <= kCarToleranceHalf) { return index = candidate; }
        if (dist < minDist)
    {
      minDist = dist;
      index = candidate;
    }
      }
    }
  }
  else
  {
    G4double minDist = kInfinity;
    std::size_t size = fFacets.size();
    for (std::size_t i = 0; i < size; ++i)
    {
      G4VFacet& facet = *fFacets[i];
      G4double dist = facet.Distance(p, minDist);
      if (dist < minDist)
      {
        minDist  = dist;
        index = (G4int)i;
      }
    }
  }
  return index;
}

GetMaxXExtent()

G4double G4TessellatedSolid::GetMaxXExtent

(

)

const

Definition at line 2117 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent

(

)

const

Definition at line 2131 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent

(

)

const

Definition at line 2145 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent

(

)

const

Definition at line 2110 of file G4TessellatedSolid.cc.

{
  return fMinExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent

(

)

const

Definition at line 2124 of file G4TessellatedSolid.cc.

{
  return fMinExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent

(

)

const

Definition at line 2138 of file G4TessellatedSolid.cc.

{
  return fMinExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets

(

)

const

Accessors.

Definition at line 786 of file G4TessellatedSolid.cc.

{
  return (G4int)fFacets.size();
}

Referenced by CalculateExtent(), operator+=(), and G4GDMLWriteSolids::TessellatedWrite().

GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 2204 of file G4TessellatedSolid.cc.

{
  // Select randomly a facet and return a random point on it
 
  auto i = (G4int)(fFacets.size()*G4QuickRand());
  return fFacets[i]->GetPointOnFace();
}

GetPolyhedron()

G4Polyhedron * G4TessellatedSolid::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 1998 of file G4TessellatedSolid.cc.

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

GetSolidClosed()

G4bool G4TessellatedSolid::GetSolidClosed

(

)

const

Definition at line 686 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

overridevirtual

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

Reimplemented from G4VSolid.

Definition at line 2186 of file G4TessellatedSolid.cc.

{
  if (fSurfaceArea != 0.) { return fSurfaceArea; }
 
  G4AutoLock l(&tessMutex);
  std::size_t size = fFacets.size();
  for (std::size_t i = 0; i < size; ++i)
  {
    G4VFacet &facet = *fFacets[i];
    fSurfaceArea += facet.GetArea();
  }
  l.unlock();
 
  return fSurfaceArea;
}

GetVoxels()

G4Voxelizer & G4TessellatedSolid::GetVoxels ( )

inline

Returns the voxels structure.

Definition at line 486 of file G4TessellatedSolid.hh.

{
  return fVoxels;
}

Inside()

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

overridevirtual

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

Implements G4VSolid.

Definition at line 1837 of file G4TessellatedSolid.cc.

{
  EInside location;
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    location = InsideVoxels(aPoint);
  }
  else
  {
    location = InsideNoVoxels(aPoint);
  }
  return location;
}

Referenced by DistanceToIn(), DistanceToOut(), SafetyFromInside(), and SafetyFromOutside().

IsFaceted()

G4bool G4TessellatedSolid::IsFaceted ( ) const

overridevirtual

Returns true as the solid has only planar faces.

Reimplemented from G4VSolid.

Definition at line 1792 of file G4TessellatedSolid.cc.

{
  return true;
}

Normal()

G4bool G4TessellatedSolid::Normal ( const G4ThreeVector & p, G4ThreeVector & n ) const

virtual

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

Parameters

[in]	p	The point coordinates.
[out]	n	The returned normal vector.

Returns

false if not a valid normal.

Definition at line 1192 of file G4TessellatedSolid.cc.

{
  G4double minDist;
  G4VFacet* facet = nullptr;
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    vector<G4int> curVoxel(3);
    fVoxels.GetVoxel(curVoxel, p);
    const vector<G4int> &candidates = fVoxels.GetCandidates(curVoxel);
    // fVoxels.GetCandidatesVoxelArray(p, candidates, 0);
 
    if (auto limit = (G4int)candidates.size())
    {
      minDist = kInfinity;
      for(G4int i = 0 ; i < limit ; ++i)
      {
        G4int candidate = candidates[i];
        G4VFacet &fct = *fFacets[candidate];
        G4double dist = fct.Distance(p,minDist);
        if (dist < minDist) { minDist = dist; }
        if (dist <= kCarToleranceHalf)
        {
          aNormal = fct.GetSurfaceNormal();
          return true;
        }
      }
    }
    minDist = MinDistanceFacet(p, true, facet);
  }
  else
  {
    minDist = kInfinity;
    std::size_t size = fFacets.size();
    for (std::size_t i = 0; i < size; ++i)
    {
      G4VFacet& f = *fFacets[i];
      G4double dist = f.Distance(p, minDist);
      if (dist < minDist)
      {
        minDist  = dist;
        facet = &f;
      }
    }
  }
 
  if (minDist != kInfinity)
  {
    if (facet != nullptr)  { aNormal = facet->GetSurfaceNormal(); }
    return minDist <= kCarToleranceHalf;
  }
  
#ifdef G4VERBOSE
  std::ostringstream message;
  message << "Point p is not on surface !?" << G4endl
          << "          No facets found for point: " << p << " !" << G4endl
          << "          Returning approximated value for normal.";
 
  G4Exception("G4TessellatedSolid::SurfaceNormal(p)",
              "GeomSolids1002", JustWarning, message );
#endif
 
  aNormal = (p.z() > 0 ? G4ThreeVector(0,0,1) : G4ThreeVector(0,0,-1));
  return false;
}

Referenced by SurfaceNormal().

operator+=()

G4TessellatedSolid & G4TessellatedSolid::operator+=

(

const G4TessellatedSolid &

right

)

Operator +=, allowing to add two tessellated solids together, so that the solid on the left includes all of the facets in the solid on the right. To note that copies of the facets are generated, rather than using the original facet set of the solid on the right.

Definition at line 772 of file G4TessellatedSolid.cc.

{
  G4int size = right.GetNumberOfFacets();
  for (G4int i = 0; i < size; ++i) {
    AddFacet(right.GetFacet(i)->GetClone());
}
 
  return *this;
}

operator=()

G4TessellatedSolid & G4TessellatedSolid::operator=

(

const G4TessellatedSolid &

right

)

Definition at line 138 of file G4TessellatedSolid.cc.

{
  if (&ts == this) { return *this; }
 
  // Copy base class data
  G4VSolid::operator=(ts);
 
  DeleteObjects ();
 
  Initialize();
 
  CopyObjects (ts);
 
  return *this;
}

Referenced by G4ExtrudedSolid::operator=().

SafetyFromInside()

G4double G4TessellatedSolid::SafetyFromInside ( const G4ThreeVector & p, G4bool aAccurate = false ) const

virtual

Returns the the safety distance from inside the solid at a point 'p'.

Parameters

[in]	p	The point coordinates.
[in]	aAccurate	Not used.

Returns

The safety distance.

Definition at line 1734 of file G4TessellatedSolid.cc.

{
#if G4SPECSDEBUG
  if ( Inside(p) == kOutside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16) ;
    message << "Point p is already outside!?" << G4endl
      << "Position:"  << G4endl << G4endl
      << "p.x() = "   << p.x()/mm << " mm" << G4endl
      << "p.y() = "   << p.y()/mm << " mm" << G4endl
      << "p.z() = "   << p.z()/mm << " mm" << G4endl
      << "DistanceToIn(p) == " << DistanceToIn(p);
    message.precision(oldprc) ;
    G4Exception("G4TriangularFacet::DistanceToOut(p)",
                "GeomSolids1002", JustWarning, message);
  }
#endif
 
  G4double minDist;
 
  if (OutsideOfExtent(p, kCarTolerance)) { return 0.0; }
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    G4VFacet* facet;
    minDist = MinDistanceFacet(p, true, facet);
  }
  else
  {
    minDist = kInfinity;
    G4double dist = 0.0;
    std::size_t size = fFacets.size();
    for (std::size_t i = 0; i < size; ++i)
    {
      G4VFacet& facet = *fFacets[i];
      dist = facet.Distance(p,minDist);
      if (dist < minDist) { minDist  = dist; }
    }
  }
  return minDist;
}

Referenced by DistanceToOut().

SafetyFromOutside()

G4double G4TessellatedSolid::SafetyFromOutside ( const G4ThreeVector & p, G4bool aAccurate = false ) const

virtual

Returns the the safety distance from outside the solid at a point 'p'.

Parameters

[in]	p	The point coordinates.
[in]	aAccurate	Accuracy flag, if false quickly computes and returns the distance to the voxels bounding-box.

Returns

The safety distance.

Definition at line 1676 of file G4TessellatedSolid.cc.

{
#if G4SPECSDEBUG
  if ( Inside(p) == kInside )
  {
    std::ostringstream message;
    G4int oldprc = message.precision(16) ;
    message << "Point p is already inside!?" << G4endl
      << "Position:"  << G4endl << G4endl
      << "p.x() = "   << p.x()/mm << " mm" << G4endl
      << "p.y() = "   << p.y()/mm << " mm" << G4endl
      << "p.z() = "   << p.z()/mm << " mm" << G4endl
      << "DistanceToOut(p) == " << DistanceToOut(p);
    message.precision(oldprc) ;
    G4Exception("G4TriangularFacet::DistanceToIn(p)",
                "GeomSolids1002", JustWarning, message);
  }
#endif
 
  G4double minDist;
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    if (!aAccurate) { return fVoxels.DistanceToBoundingBox(p); }
 
    if (!OutsideOfExtent(p, kCarTolerance))
    {
      vector<G4int> startingVoxel(3);
      fVoxels.GetVoxel(startingVoxel, p);
      const vector<G4int> &candidates = fVoxels.GetCandidates(startingVoxel);
      if (candidates.empty() && (fInsides.GetNbits() != 0u))
      {
        G4int index = fVoxels.GetPointIndex(p);
        if (fInsides[index]) { return 0.; }
      }
    }
 
    G4VFacet* facet;
    minDist = MinDistanceFacet(p, true, facet);
  }
  else
  {
    minDist = kInfinity;
    std::size_t size = fFacets.size();
    for (std::size_t i = 0; i < size; ++i)
    {
      G4VFacet& facet = *fFacets[i];
      G4double dist = facet.Distance(p,minDist);
      if (dist < minDist) { minDist = dist; }
    }
  }
  return minDist;
}

Referenced by DistanceToIn().

SetMaxVoxels()

void G4TessellatedSolid::SetMaxVoxels ( G4int max )

inline

Allowing to tune the maximum number of voxels to use for optimisation.

Definition at line 481 of file G4TessellatedSolid.hh.

{
  fVoxels.SetMaxVoxels(max);
}

SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed

(

const G4bool

t

)

Modifier and accessor to close/finalise the solid.

Definition at line 622 of file G4TessellatedSolid.cc.

{
  if (t)
  {
#ifdef G4SPECSDEBUG
    G4cout << "Creating vertex list..." << G4endl;
#endif
    CreateVertexList();
 
#ifdef G4SPECSDEBUG
    G4cout << "Setting extreme facets..." << G4endl;
#endif
    SetExtremeFacets();
 
#ifdef G4SPECSDEBUG
    G4cout << "Voxelizing..." << G4endl;
#endif
    Voxelize();
 
#ifdef G4SPECSDEBUG
    DisplayAllocatedMemory();
#endif
 
#ifdef G4SPECSDEBUG
    G4cout << "Checking Structure..." << G4endl;
#endif
    G4int irep = CheckStructure();
    if (irep != 0)
    {
      if ((irep & 1) != 0)
      {
         std::ostringstream message;
         message << "Defects in solid: " << GetName()
                 << " - negative cubic volume, please check orientation of facets!";
         G4Exception("G4TessellatedSolid::SetSolidClosed()",
                     "GeomSolids1001", JustWarning, message);
      }
      if ((irep & 2) != 0)
      {
         std::ostringstream message;
         message << "Defects in solid: " << GetName()
                 << " - some facets have wrong orientation!";
         G4Exception("G4TessellatedSolid::SetSolidClosed()",
                     "GeomSolids1001", JustWarning, message);
      }
      if ((irep & 4) != 0)
      {
         std::ostringstream message;
         message << "Defects in solid: " << GetName()
                 << " - there are holes in the surface!";
         G4Exception("G4TessellatedSolid::SetSolidClosed()",
                     "GeomSolids1001", JustWarning, message);
      }
    }
  }
  fSolidClosed = t;
}

Referenced by G4GDMLReadSolids::TessellatedRead().

StreamInfo()

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

overridevirtual

Streams the object contents to an output stream.

Implements G4VSolid.

Definition at line 1799 of file G4TessellatedSolid.cc.

{
  os << G4endl;
  os << "Solid name       = " << GetName()      << G4endl;
  os << "Geometry Type    = " << fGeometryType  << G4endl;
  os << "Number of facets = " << fFacets.size() << G4endl;
 
  std::size_t size = fFacets.size();
  for (std::size_t i = 0; i < size; ++i)
  {
    os << "FACET #          = " << i + 1 << G4endl;
    G4VFacet &facet = *fFacets[i];
    facet.StreamInfo(os);
  }
  os << G4endl;
 
  return os;
}

SurfaceNormal()

G4ThreeVector G4TessellatedSolid::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 1854 of file G4TessellatedSolid.cc.

{
  G4ThreeVector n;
  Normal(p, n);
  return n;
}

Referenced by G4ExtrudedSolid::SurfaceNormal().

Member Data Documentation

kCarToleranceHalf

G4double G4TessellatedSolid::kCarToleranceHalf

protected

Definition at line 440 of file G4TessellatedSolid.hh.

Referenced by CalculateExtent(), G4ExtrudedSolid::DistanceToIn(), G4ExtrudedSolid::DistanceToOut(), G4ExtrudedSolid::G4ExtrudedSolid(), GetFacetIndex(), G4ExtrudedSolid::Inside(), Normal(), and G4ExtrudedSolid::SurfaceNormal().

---

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

• G4TessellatedSolid.hh
• G4TessellatedSolid.cc