G4TessellatedSolid Class Reference

#include <G4TessellatedSolid.hh>

Inheritance diagram for G4TessellatedSolid:

Public Member Functions
	G4TessellatedSolid ()
virtual	~G4TessellatedSolid ()
	G4TessellatedSolid (const G4String &name)
	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
virtual EInside	Inside (const G4ThreeVector &p) const
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const
virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const
virtual G4double	DistanceToIn (const G4ThreeVector &p) const
virtual G4double	DistanceToOut (const G4ThreeVector &p) const
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm, G4bool *validNorm, G4ThreeVector *norm) const
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
virtual G4GeometryType	GetEntityType () const
virtual std::ostream &	StreamInfo (std::ostream &os) const
virtual G4VSolid *	Clone () const
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4double	GetSurfaceArea ()
virtual G4double	GetCubicVolume ()
void	SetSolidClosed (const G4bool t)
G4bool	GetSolidClosed () const
G4int	CheckStructure () const
void	SetMaxVoxels (G4int max)
G4Voxelizer &	GetVoxels ()
virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const
G4double	GetMinXExtent () const
G4double	GetMaxXExtent () const
G4double	GetMinYExtent () const
G4double	GetMaxYExtent () const
G4double	GetMinZExtent () const
G4double	GetMaxZExtent () const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const
virtual G4VisExtent	GetExtent () const
G4int	AllocatedMemoryWithoutVoxels ()
G4int	AllocatedMemory ()
void	DisplayAllocatedMemory ()
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
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 G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const =0
virtual EInside	Inside (const G4ThreeVector &p) const =0
virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const =0
virtual G4double	DistanceToIn (const G4ThreeVector &p) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4double	GetCubicVolume ()
virtual G4double	GetSurfaceArea ()
virtual G4GeometryType	GetEntityType () const =0
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4VSolid *	Clone () const
virtual std::ostream &	StreamInfo (std::ostream &os) const =0
void	DumpInfo () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0
virtual G4VisExtent	GetExtent () const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) 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

Definition at line 127 of file G4TessellatedSolid.hh.

Constructor & Destructor Documentation

G4TessellatedSolid() [1/4]

G4TessellatedSolid::G4TessellatedSolid

(

)

Definition at line 86 of file G4TessellatedSolid.cc.

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

Referenced by Clone().

~G4TessellatedSolid()

G4TessellatedSolid::~G4TessellatedSolid ( )

virtual

Definition at line 116 of file G4TessellatedSolid.cc.

{
  DeleteObjects();
}

G4TessellatedSolid() [2/4]

G4TessellatedSolid::G4TessellatedSolid

(

const G4String &

name

)

Definition at line 96 of file G4TessellatedSolid.cc.

  : G4VSolid(name)
{
  Initialize();
}

G4TessellatedSolid() [3/4]

G4TessellatedSolid::G4TessellatedSolid

(

__void__ &

a

)

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

)

Definition at line 125 of file G4TessellatedSolid.cc.

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

Member Function Documentation

AddFacet()

G4bool G4TessellatedSolid::AddFacet

(

G4VFacet *

aFacet

)

Definition at line 207 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;
  }
  else 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;
  }
  else
  {
    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 2239 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

(

)

Definition at line 2216 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 (auto it = fExtremeFacets.cbegin(); it != fExtremeFacets.cend(); ++it)
  {
    G4VFacet &facet = *(*it);
    base += facet.AllocatedMemory();
  }
  return base;
}

Referenced by AllocatedMemory(), and DisplayAllocatedMemory().

BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 1973 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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1999 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

Definition at line 671 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()));
  }
  G4int ivolume = (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);
      int64_t inverse = (i2 > i1);
      if (inverse) 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

virtual

Reimplemented from G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1777 of file G4TessellatedSolid.cc.

{
  return new G4TessellatedSolid(*this);
}

CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1922 of file G4TessellatedSolid.cc.

{
  G4int nVertices = (G4int)fVertexList.size();
  G4int nFacets = (G4int)fFacets.size();
  G4Polyhedron* 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 G4GenericTrap::CreatePolyhedron(), and GetPolyhedron().

DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 1915 of file G4TessellatedSolid.cc.

{
  scene.AddSolid (*this);
}

Referenced by G4GenericTrap::DescribeYourselfTo().

DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory

(

)

Definition at line 581 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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1823 of file G4TessellatedSolid.cc.

{
  return SafetyFromOutside(p, false);
}

DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1830 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(), G4GenericTrap::DistanceToIn(), and SafetyFromInside().

DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1858 of file G4TessellatedSolid.cc.

{
  return SafetyFromInside(p, false);
}

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

DistanceToOut() [2/2]

G4double G4TessellatedSolid::DistanceToOut ( const G4ThreeVector &  p, const G4ThreeVector &  v, const G4bool  calcNorm, G4bool *  validNorm, G4ThreeVector *  norm  ) const

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1881 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 ( )

virtual

Reimplemented from G4VSolid.

Definition at line 2113 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
 
  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.;
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4TessellatedSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1747 of file G4TessellatedSolid.cc.

{
  return fGeometryType;
}

GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 2104 of file G4TessellatedSolid.cc.

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

Referenced by G4GenericTrap::GetExtent().

GetFacet()

G4VFacet * G4TessellatedSolid::GetFacet ( G4int  i ) const

inline

Definition at line 304 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 1099 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 (G4int 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 2069 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent

(

)

const

Definition at line 2083 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent

(

)

const

Definition at line 2097 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent

(

)

const

Definition at line 2062 of file G4TessellatedSolid.cc.

{
  return fMinExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent

(

)

const

Definition at line 2076 of file G4TessellatedSolid.cc.

{
  return fMinExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent

(

)

const

Definition at line 2090 of file G4TessellatedSolid.cc.

{
  return fMinExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets

(

)

const

Definition at line 755 of file G4TessellatedSolid.cc.

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

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

GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 2150 of file G4TessellatedSolid.cc.

{
  // Select randomly a facet and return a random point on it
 
  G4int i = (G4int) G4RandFlat::shoot(0., fFacets.size());
  return fFacets[i]->GetPointOnFace();
}

Referenced by G4GenericTrap::GetPointOnSurface().

GetPolyhedron()

G4Polyhedron * G4TessellatedSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

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

Referenced by G4GenericTrap::GetPolyhedron().

GetSolidClosed()

G4bool G4TessellatedSolid::GetSolidClosed

(

)

const

Definition at line 656 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 2135 of file G4TessellatedSolid.cc.

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

GetVoxels()

G4Voxelizer & G4TessellatedSolid::GetVoxels ( )

inline

Definition at line 314 of file G4TessellatedSolid.hh.

{
  return fVoxels;
}

Inside()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1792 of file G4TessellatedSolid.cc.

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

Referenced by DistanceToIn(), DistanceToOut(), G4GenericTrap::Inside(), SafetyFromInside(), and SafetyFromOutside().

Normal()

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

virtual

Definition at line 1148 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 (G4int 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)  { aNormal = facet->GetSurfaceNormal(); }
    return minDist <= kCarToleranceHalf;
  }
  else
  {
#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

)

Definition at line 742 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

Definition at line 1698 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

Definition at line 1639 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.size() == 0 && fInsides.GetNbits())
      {
        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

Definition at line 309 of file G4TessellatedSolid.hh.

{
  fVoxels.SetMaxVoxels(max);
}

SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed

(

const G4bool

t

)

Definition at line 592 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)
      {
         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)
      {
         std::ostringstream message;
         message << "Defects in solid: " << GetName()
                 << " - some facets have wrong orientation!";
         G4Exception("G4TessellatedSolid::SetSolidClosed()",
                     "GeomSolids1001", JustWarning, message);
      }
      if (irep & 4)
      {
         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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1754 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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1809 of file G4TessellatedSolid.cc.

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

Referenced by G4ExtrudedSolid::SurfaceNormal(), and G4GenericTrap::SurfaceNormal().

Member Data Documentation

kCarToleranceHalf

G4double G4TessellatedSolid::kCarToleranceHalf

protected

Definition at line 268 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