G4TessellatedSolid Class Reference

#include <G4TessellatedSolid.hh>

Inheritance diagram for G4TessellatedSolid:

Public Member Functions
	G4TessellatedSolid ()
	~G4TessellatedSolid () override
	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
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
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
G4double	GetMinXExtent () const
G4double	GetMaxXExtent () const
G4double	GetMinYExtent () const
G4double	GetMaxYExtent () const
G4double	GetMinZExtent () const
G4double	GetMaxZExtent () const
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 ()
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)
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__ &)
	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 85 of file G4TessellatedSolid.cc.

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

Referenced by Clone().

~G4TessellatedSolid()

G4TessellatedSolid::~G4TessellatedSolid ( )

override

Definition at line 115 of file G4TessellatedSolid.cc.

{
  DeleteObjects();
}

G4TessellatedSolid() [2/4]

G4TessellatedSolid::G4TessellatedSolid

(

const G4String &

name

)

Definition at line 95 of file G4TessellatedSolid.cc.

  : G4VSolid(name)
{
  Initialize();
}

G4TessellatedSolid() [3/4]

G4TessellatedSolid::G4TessellatedSolid

(

__void__ &

a

)

Definition at line 106 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 124 of file G4TessellatedSolid.cc.

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

Member Function Documentation

AddFacet()

G4bool G4TessellatedSolid::AddFacet

(

G4VFacet *

aFacet

)

Definition at line 206 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 2238 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 2215 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

Reimplemented from G4VSolid.

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

Implements G4VSolid.

Definition at line 1998 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 670 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 = 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);
      int64_t 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

Reimplemented from G4VSolid.

Definition at line 1776 of file G4TessellatedSolid.cc.

{
  return new G4TessellatedSolid(*this);
}

CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 1921 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 G4GenericTrap::CreatePolyhedron(), and GetPolyhedron().

DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Implements G4VSolid.

Definition at line 1914 of file G4TessellatedSolid.cc.

{
  scene.AddSolid (*this);
}

Referenced by G4GenericTrap::DescribeYourselfTo().

DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory

(

)

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

Implements G4VSolid.

Definition at line 1822 of file G4TessellatedSolid.cc.

{
  return SafetyFromOutside(p, false);
}

DistanceToIn() [2/2]

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

overridevirtual

Implements G4VSolid.

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

DistanceToOut() [1/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 1857 of file G4TessellatedSolid.cc.

{
  return SafetyFromInside(p, false);
}

Referenced by G4ExtrudedSolid::DistanceToOut(), G4ExtrudedSolid::DistanceToOut(), G4GenericTrap::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

overridevirtual

Implements G4VSolid.

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

Reimplemented from G4VSolid.

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

overridevirtual

Implements G4VSolid.

Definition at line 1746 of file G4TessellatedSolid.cc.

{
  return fGeometryType;
}

GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 2103 of file G4TessellatedSolid.cc.

{
  return { 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 1098 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 2068 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent

(

)

const

Definition at line 2082 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent

(

)

const

Definition at line 2096 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent

(

)

const

Definition at line 2061 of file G4TessellatedSolid.cc.

{
  return fMinExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent

(

)

const

Definition at line 2075 of file G4TessellatedSolid.cc.

{
  return fMinExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent

(

)

const

Definition at line 2089 of file G4TessellatedSolid.cc.

{
  return fMinExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets

(

)

const

Definition at line 754 of file G4TessellatedSolid.cc.

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

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

GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 2149 of file G4TessellatedSolid.cc.

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

Referenced by G4GenericTrap::GetPointOnSurface().

GetPolyhedron()

G4Polyhedron * G4TessellatedSolid::GetPolyhedron ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 1952 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 655 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

overridevirtual

Reimplemented from G4VSolid.

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

overridevirtual

Implements G4VSolid.

Definition at line 1791 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 1147 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;
  }
  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 741 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 137 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 1697 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 1638 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

Definition at line 309 of file G4TessellatedSolid.hh.

{
  fVoxels.SetMaxVoxels(max);
}

SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed

(

const G4bool

t

)

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

Implements G4VSolid.

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

Implements G4VSolid.

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