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
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
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 = 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 2065 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 2042 of file G4TessellatedSolid.cc.

{
  G4int base = sizeof(*this);
  base += fVertexList.capacity() * sizeof(G4ThreeVector);
  base += fRandir.capacity() * sizeof(G4ThreeVector);
 
  G4int limit = fFacets.size();
  for (G4int 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 1799 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 1825 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
}

Clone()

G4VSolid * G4TessellatedSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1600 of file G4TessellatedSolid.cc.

{
  return new G4TessellatedSolid(*this);
}

CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1745 of file G4TessellatedSolid.cc.

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

Referenced by G4GenericTrap::CreatePolyhedron(), and GetPolyhedron().

DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 1738 of file G4TessellatedSolid.cc.

{
  scene.AddSolid (*this);
}

Referenced by G4GenericTrap::DescribeYourselfTo().

DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory

(

)

Definition at line 555 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 1646 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 1653 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 1681 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 1704 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 1939 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
 
  G4int size = fFacets.size();
  for (G4int 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 1570 of file G4TessellatedSolid.cc.

{
  return fGeometryType;
}

GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1930 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 302 of file G4TessellatedSolid.hh.

{
  return fFacets[i];
}

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

GetMaxXExtent()

G4double G4TessellatedSolid::GetMaxXExtent

(

)

const

Definition at line 1895 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent

(

)

const

Definition at line 1909 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent

(

)

const

Definition at line 1923 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent

(

)

const

Definition at line 1888 of file G4TessellatedSolid.cc.

{
  return fMinExtent.x();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent

(

)

const

Definition at line 1902 of file G4TessellatedSolid.cc.

{
  return fMinExtent.y();
}

Referenced by G4ExtrudedSolid::Inside().

GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent

(

)

const

Definition at line 1916 of file G4TessellatedSolid.cc.

{
  return fMinExtent.z();
}

Referenced by G4ExtrudedSolid::Inside().

GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets

(

)

const

Definition at line 627 of file G4TessellatedSolid.cc.

{
  return fFacets.size();
}

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

GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1976 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 1779 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 599 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

Definition at line 1961 of file G4TessellatedSolid.cc.

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

GetVoxels()

G4Voxelizer & G4TessellatedSolid::GetVoxels ( )

inline

Definition at line 312 of file G4TessellatedSolid.hh.

{
  return fVoxels;
}

Inside()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1615 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 971 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 = 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;
    G4int size = fFacets.size();
    for (G4int 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 614 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 1521 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;
    G4int size = fFacets.size();
    for (G4int 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 1462 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;
    G4int size = fFacets.size();
    for (G4int 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 307 of file G4TessellatedSolid.hh.

{
  fVoxels.SetMaxVoxels(max);
}

SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed

(

const G4bool

t

)

Definition at line 566 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
 
  }  
  fSolidClosed = t;
}

Referenced by G4GDMLReadSolids::TessellatedRead().

StreamInfo()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1577 of file G4TessellatedSolid.cc.

{
  os << G4endl;
  os << "Solid name       = " << GetName()      << G4endl;
  os << "Geometry Type    = " << fGeometryType  << G4endl;
  os << "Number of facets = " << fFacets.size() << G4endl;
 
  G4int size = fFacets.size();
  for (G4int 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 1632 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 266 of file G4TessellatedSolid.hh.

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

---

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

• G4TessellatedSolid.hh
• G4TessellatedSolid.cc