#include <G4TessellatedSolid.hh>

Inheritance diagram for G4TessellatedSolid:

Public Member Functions
G4bool	AddFacet (G4VFacet *aFacet)

G4int	AllocatedMemory ()

G4int	AllocatedMemoryWithoutVoxels ()

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

virtual G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const

G4int	CheckStructure () const

virtual G4VSolid *	Clone () const

virtual void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep)

virtual G4Polyhedron *	CreatePolyhedron () const

virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const

void	DisplayAllocatedMemory ()

virtual G4double	DistanceToIn (const G4ThreeVector &p) const

virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) 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

void	DumpInfo () const

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

	G4TessellatedSolid ()

	G4TessellatedSolid (__void__ &)

	G4TessellatedSolid (const G4String &name)

	G4TessellatedSolid (const G4TessellatedSolid &ts)

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4double	GetCubicVolume ()

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4GeometryType	GetEntityType () const

virtual G4VisExtent	GetExtent () const

G4VFacet *	GetFacet (G4int i) const

G4int	GetFacetIndex (const G4ThreeVector &p) const

G4double	GetMaxXExtent () const

G4double	GetMaxYExtent () const

G4double	GetMaxZExtent () const

G4double	GetMinXExtent () const

G4double	GetMinYExtent () const

G4double	GetMinZExtent () const

G4String	GetName () const

G4int	GetNumberOfFacets () const

virtual G4ThreeVector	GetPointOnSurface () const

virtual G4Polyhedron *	GetPolyhedron () const

G4bool	GetSolidClosed () const

virtual G4double	GetSurfaceArea ()

G4double	GetTolerance () const

G4Voxelizer &	GetVoxels ()

virtual EInside	Inside (const G4ThreeVector &p) const

virtual G4bool	Normal (const G4ThreeVector &p, G4ThreeVector &n) const

G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)

G4TessellatedSolid &	operator= (const G4TessellatedSolid &right)

G4bool	operator== (const G4VSolid &s) const

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

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

void	SetMaxVoxels (G4int max)

void	SetName (const G4String &name)

void	SetSolidClosed (const G4bool t)

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

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

virtual	~G4TessellatedSolid ()

Protected Member Functions
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, 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	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const

Protected Attributes
G4double	kCarTolerance

G4double	kCarToleranceHalf

Private Member Functions
void	ClipPolygonToSimpleLimits (G4ThreeVectorList &pPolygon, G4ThreeVectorList &outputPolygon, const G4VoxelLimits &pVoxelLimit) const

void	CopyObjects (const G4TessellatedSolid &s)

void	CreateVertexList ()

void	DeleteObjects ()

G4double	DistanceToInCandidates (const std::vector< G4int > &candidates, const G4ThreeVector &aPoint, const G4ThreeVector &aDirection) const

G4double	DistanceToInCore (const G4ThreeVector &p, const G4ThreeVector &v, G4double aPstep=kInfinity) const

G4double	DistanceToInNoVoxels (const G4ThreeVector &p, const G4ThreeVector &v, G4double aPstep=kInfinity) const

void	DistanceToOutCandidates (const std::vector< G4int > &candidates, const G4ThreeVector &aPoint, const G4ThreeVector &direction, G4double &minDist, G4ThreeVector &minNormal, G4int &minCandidate) const

G4double	DistanceToOutCore (const G4ThreeVector &p, const G4ThreeVector &v, G4ThreeVector &aNormalVector, G4bool &aConvex, G4double aPstep=kInfinity) const

G4double	DistanceToOutNoVoxels (const G4ThreeVector &p, const G4ThreeVector &v, G4ThreeVector &aNormalVector, G4bool &aConvex, G4double aPstep=kInfinity) const

void	Initialize ()

EInside	InsideNoVoxels (const G4ThreeVector &p) const

EInside	InsideVoxels (const G4ThreeVector &aPoint) const

G4double	MinDistanceFacet (const G4ThreeVector &p, G4bool simple, G4VFacet *&facet) const

G4bool	OutsideOfExtent (const G4ThreeVector &p, G4double tolerance=0.0) const

void	PrecalculateInsides ()

G4int	SetAllUsingStack (const std::vector< G4int > &voxel, const std::vector< G4int > &max, G4bool status, G4SurfBits &checked)

void	SetExtremeFacets ()

void	SetRandomVectors ()

void	Voxelize ()

Static Private Member Functions
static G4bool	CompareSortedVoxel (const std::pair< G4int, G4double > &l, const std::pair< G4int, G4double > &r)

Private Attributes
G4double	fCubicVolume = 0.0

std::set< G4VFacet * >	fExtremeFacets

std::set< G4VertexInfo, G4VertexComparator >	fFacetList

std::vector< G4VFacet * >	fFacets

G4GeometryType	fGeometryType

G4SurfBits	fInsides

G4ThreeVector	fMaxExtent

G4int	fMaxTries

G4ThreeVector	fMinExtent

G4Polyhedron *	fpPolyhedron = nullptr

std::vector< G4ThreeVector >	fRandir

G4bool	fRebuildPolyhedron = false

G4String	fshapeName

G4bool	fSolidClosed = false

G4double	fSurfaceArea = 0.0

std::vector< G4ThreeVector >	fVertexList

G4Voxelizer	fVoxels

Detailed Description

Definition at line 127 of file G4TessellatedSolid.hh.

Constructor & Destructor Documentation

◆ G4TessellatedSolid() [1/4]

G4TessellatedSolid::G4TessellatedSolid ( )

Definition at line 87 of file G4TessellatedSolid.cc.

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

References Initialize().

Referenced by Clone().

◆ ~G4TessellatedSolid()

G4TessellatedSolid::~G4TessellatedSolid ( )

virtual

Definition at line 117 of file G4TessellatedSolid.cc.

{
  DeleteObjects();
}

References DeleteObjects().

◆ G4TessellatedSolid() [2/4]

G4TessellatedSolid::G4TessellatedSolid ( const G4String & name )

Definition at line 97 of file G4TessellatedSolid.cc.

  : G4VSolid(name)
{
  Initialize();
}

References Initialize().

◆ G4TessellatedSolid() [3/4]

G4TessellatedSolid::G4TessellatedSolid ( __void__ & a )

Definition at line 108 of file G4TessellatedSolid.cc.

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

References fMaxExtent, fMinExtent, Initialize(), and CLHEP::Hep3Vector::set().

◆ G4TessellatedSolid() [4/4]

G4TessellatedSolid::G4TessellatedSolid ( const G4TessellatedSolid & ts )

Definition at line 126 of file G4TessellatedSolid.cc.

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

References CopyObjects(), Initialize(), and geant4_check_module_cycles::ts.

Member Function Documentation

◆ AddFacet()

G4bool G4TessellatedSolid::AddFacet ( G4VFacet * aFacet )

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

References fFacetList, fFacets, fSolidClosed, G4cout, G4Exception(), G4VFacet::GetCircumcentre(), G4VertexInfo::id, G4VFacet::IsDefined(), JustWarning, G4VSolid::kCarTolerance, G4VertexInfo::mag2, OutsideOfExtent(), pos, G4VFacet::StreamInfo(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4ExtrudedSolid::AddGeneralPolygonFacets(), CopyObjects(), G4GenericTrap::CreateTessellatedSolid(), G4tgbVolume::FindOrConstructG4Solid(), G4ExtrudedSolid::MakeFacets(), operator+=(), and G4GDMLReadSolids::TessellatedRead().

◆ AllocatedMemory()

G4int G4TessellatedSolid::AllocatedMemory ( )

Definition at line 2248 of file G4TessellatedSolid.cc.

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

References G4Voxelizer::AllocatedMemory(), AllocatedMemoryWithoutVoxels(), fInsides, fVoxels, and G4SurfBits::GetNbytes().

Referenced by DisplayAllocatedMemory().

◆ AllocatedMemoryWithoutVoxels()

G4int G4TessellatedSolid::AllocatedMemoryWithoutVoxels ( )

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

References G4VFacet::AllocatedMemory(), fExtremeFacets, fFacets, fRandir, and fVertexList.

Referenced by AllocatedMemory(), and DisplayAllocatedMemory().

◆ BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

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

References G4VSolid::DumpInfo(), fMaxExtent, fMinExtent, G4Exception(), G4VSolid::GetName(), JustWarning, pMax, and pMin.

Referenced by CalculateExtent().

◆ CalculateClippedPolygonExtent()

void G4VSolid::CalculateClippedPolygonExtent	(	G4ThreeVectorList &	pPolygon,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis,
		G4double &	pMin,
		G4double &	pMax
	)		const

protectedinherited

Definition at line 489 of file G4VSolid.cc.

{
  G4int noLeft,i;
  G4double component;
 
  ClipPolygon(pPolygon,pVoxelLimit,pAxis);
  noLeft = pPolygon.size();
 
  if ( noLeft )
  {
    for (i=0; i<noLeft; ++i)
    {
      component = pPolygon[i].operator()(pAxis);
 
      if (component < pMin)
      {
        pMin = component;
      }
      if (component > pMax)
      {
        pMax = component;
      }
    }
  }
}

References G4VSolid::ClipPolygon(), pMax, and pMin.

Referenced by G4VSolid::ClipBetweenSections(), and G4VSolid::ClipCrossSection().

◆ 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 2008 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
}

References G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), BoundingLimits(), G4BoundingEnvelope::CalculateExtent(), emax, GetFacet(), G4VoxelLimits::GetMaxExtent(), G4VoxelLimits::GetMinExtent(), GetNumberOfFacets(), G4VFacet::GetNumberOfVertices(), G4VFacet::GetSurfaceNormal(), G4VFacet::GetVertex(), kCarToleranceHalf, kInfinity, pMax, and pMin.

Referenced by G4STRead::PhysvolRead().

◆ CheckStructure()

G4int G4TessellatedSolid::CheckStructure ( ) const

Definition at line 677 of file G4TessellatedSolid.cc.

{
  G4int nedge = 0;
  G4int nface = fFacets.size();
 
  // Calculate volume
  //
  G4double volume = 0.;
  for (G4int 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 (G4int 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;
}

References CLHEP::Hep3Vector::dot(), fFacets, G4VFacet::GetArea(), G4VFacet::GetNumberOfVertices(), G4VFacet::GetSurfaceNormal(), G4VFacet::GetVertex(), and G4VFacet::GetVertexIndex().

Referenced by SetSolidClosed().

◆ ClipBetweenSections()

void G4VSolid::ClipBetweenSections	(	G4ThreeVectorList *	pVertices,
		const G4int	pSectionIndex,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis,
		G4double &	pMin,
		G4double &	pMax
	)		const

protectedinherited

Definition at line 444 of file G4VSolid.cc.

{
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+5]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+6]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  polygon.clear();
 
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  polygon.push_back((*pVertices)[pSectionIndex+7]);
  polygon.push_back((*pVertices)[pSectionIndex+4]);
  polygon.push_back((*pVertices)[pSectionIndex]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

◆ ClipCrossSection()

void G4VSolid::ClipCrossSection	(	G4ThreeVectorList *	pVertices,
		const G4int	pSectionIndex,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis,
		G4double &	pMin,
		G4double &	pMax
	)		const

protectedinherited

Definition at line 414 of file G4VSolid.cc.

{
 
  G4ThreeVectorList polygon;
  polygon.reserve(4);
  polygon.push_back((*pVertices)[pSectionIndex]);
  polygon.push_back((*pVertices)[pSectionIndex+1]);
  polygon.push_back((*pVertices)[pSectionIndex+2]);
  polygon.push_back((*pVertices)[pSectionIndex+3]);
  CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
  return;
}

References G4VSolid::CalculateClippedPolygonExtent(), pMax, and pMin.

◆ ClipPolygon()

void G4VSolid::ClipPolygon	(	G4ThreeVectorList &	pPolygon,
		const G4VoxelLimits &	pVoxelLimit,
		const EAxis	pAxis
	)		const

protectedinherited

Definition at line 539 of file G4VSolid.cc.

{
  G4ThreeVectorList outputPolygon;
 
  if ( pVoxelLimit.IsLimited() )
  {
    if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      if ( !pPolygon.size() )       return;
      else                          outputPolygon.clear();
    }
    if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
    {
      G4VoxelLimits simpleLimit1;
      simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
      ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
 
      // Must always clear pPolygon - for clip to simpleLimit2 and in case of
      // early exit
 
      pPolygon.clear();
 
      if ( !outputPolygon.size() )  return;
 
      G4VoxelLimits simpleLimit2;
      simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
      ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
 
      // Return after final clip - no cleanup
    }
  }
}

References G4VoxelLimits::AddLimit(), G4VSolid::ClipPolygonToSimpleLimits(), G4VoxelLimits::GetMaxXExtent(), G4VoxelLimits::GetMaxYExtent(), G4VoxelLimits::GetMaxZExtent(), G4VoxelLimits::GetMinXExtent(), G4VoxelLimits::GetMinYExtent(), G4VoxelLimits::GetMinZExtent(), G4VoxelLimits::IsLimited(), G4VoxelLimits::IsXLimited(), G4VoxelLimits::IsYLimited(), G4VoxelLimits::IsZLimited(), kInfinity, kXAxis, kYAxis, and kZAxis.

Referenced by G4VSolid::CalculateClippedPolygonExtent().

◆ ClipPolygonToSimpleLimits()

void G4VSolid::ClipPolygonToSimpleLimits	(	G4ThreeVectorList &	pPolygon,
		G4ThreeVectorList &	outputPolygon,
		const G4VoxelLimits &	pVoxelLimit
	)		const

privateinherited

Definition at line 612 of file G4VSolid.cc.

{
  G4int i;
  G4int noVertices=pPolygon.size();
  G4ThreeVector vEnd,vStart;
 
  for (i = 0 ; i < noVertices ; ++i )
  {
    vStart = pPolygon[i];
    if ( i == noVertices-1 )    vEnd = pPolygon[0];
    else                        vEnd = pPolygon[i+1];
 
    if ( pVoxelLimit.Inside(vStart) )
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart and vEnd inside -> output end point
        //
        outputPolygon.push_back(vEnd);
      }
      else
      {
        // vStart inside, vEnd outside -> output crossing point
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vEnd);
      }
    }
    else
    {
      if (pVoxelLimit.Inside(vEnd))
      {
        // vStart outside, vEnd inside -> output inside section
        //
        pVoxelLimit.ClipToLimits(vStart,vEnd);
        outputPolygon.push_back(vStart);
        outputPolygon.push_back(vEnd);
      }
      else  // Both point outside -> no output
      {
        // outputPolygon.push_back(vStart);
        // outputPolygon.push_back(vEnd);
      }
    }
  }
}

References G4VoxelLimits::ClipToLimits(), and G4VoxelLimits::Inside().

Referenced by G4VSolid::ClipPolygon().

◆ Clone()

G4VSolid * G4TessellatedSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1783 of file G4TessellatedSolid.cc.

{
  return new G4TessellatedSolid(*this);
}

References G4TessellatedSolid().

◆ CompareSortedVoxel()

G4bool G4TessellatedSolid::CompareSortedVoxel	(	const std::pair< G4int, G4double > &	l,
		const std::pair< G4int, G4double > &	r
	)

staticprivate

Definition at line 1585 of file G4TessellatedSolid.cc.

{
  return l.second < r.second;
}

Referenced by MinDistanceFacet().

◆ ComputeDimensions()

void G4VSolid::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep
	)

virtualinherited

Reimplemented in G4TwistedTubs, G4VTwistedFaceted, G4ReflectedSolid, G4DisplacedSolid, G4IntersectionSolid, G4ScaledSolid, G4SubtractionSolid, G4UnionSolid, G4Box, G4Cons, G4Orb, G4Para, G4Sphere, G4Torus, G4Trap, G4Trd, G4Tubs, G4Ellipsoid, G4Hype, G4Polycone, G4Polyhedra, and G4Tet.

Definition at line 137 of file G4VSolid.cc.

{
    std::ostringstream message;
    message << "Illegal call to G4VSolid::ComputeDimensions()" << G4endl
            << "Method not overloaded by derived class !";
    G4Exception("G4VSolid::ComputeDimensions()", "GeomMgt0003",
                FatalException, message);
}

References FatalException, G4endl, and G4Exception().

Referenced by G4SmartVoxelHeader::BuildNodes(), G4PVParameterised::CheckOverlaps(), G4VPrimitiveScorer::ComputeSolid(), G4ScoreSplittingProcess::CreateTouchableForSubStep(), G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4LogicalVolume::GetMass(), G4Navigator::GetMotherToDaughterTransform(), G4ITNavigator1::GetMotherToDaughterTransform(), G4ITNavigator2::GetMotherToDaughterTransform(), G4ITNavigator1::LocateGlobalPointAndSetup(), G4ITNavigator2::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointAndSetup(), G4PSFlatSurfaceCurrent::ProcessHits(), G4PSFlatSurfaceFlux::ProcessHits(), G4PSSphereSurfaceFlux::ProcessHits(), G4PSVolumeFlux::ProcessHits(), G4Navigator::SetupHierarchy(), G4ITNavigator1::SetupHierarchy(), and G4ITNavigator2::SetupHierarchy().

◆ CopyObjects()

void G4TessellatedSolid::CopyObjects ( const G4TessellatedSolid & s )

private

Definition at line 185 of file G4TessellatedSolid.cc.

{
  G4ThreeVector reductionRatio;
  G4int fmaxVoxels = fVoxels.GetMaxVoxels(reductionRatio);
  if (fmaxVoxels < 0)
    fVoxels.SetMaxVoxels(reductionRatio);
  else
    fVoxels.SetMaxVoxels(fmaxVoxels);
 
  G4int n = ts.GetNumberOfFacets();
  for (G4int i = 0; i < n; ++i)
  {
    G4VFacet *facetClone = (ts.GetFacet(i))->GetClone();
    AddFacet(facetClone);
  }
  if (ts.GetSolidClosed()) SetSolidClosed(true);
}

References AddFacet(), fVoxels, G4Voxelizer::GetMaxVoxels(), CLHEP::detail::n, G4Voxelizer::SetMaxVoxels(), SetSolidClosed(), and geant4_check_module_cycles::ts.

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

◆ CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

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

References G4PolyhedronArbitrary::AddFacet(), G4PolyhedronArbitrary::AddVertex(), fFacets, fVertexList, G4VFacet::GetNumberOfVertices(), G4VFacet::GetVertexIndex(), CLHEP::detail::n, and G4PolyhedronArbitrary::SetReferences().

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

◆ CreateVertexList()

void G4TessellatedSolid::CreateVertexList ( )

private

Definition at line 453 of file G4TessellatedSolid.cc.

{
  // The algorithm:
  // we will have additional vertexListSorted, where all the items will be
  // sorted by magnitude of vertice vector.
  // New candidate for fVertexList - we will determine the position fo first
  // item which would be within its magnitude - 0.5*kCarTolerance.
  // We will go trough until we will reach > +0.5 kCarTolerance.
  // Comparison (q-p).mag() < 0.5*kCarTolerance will be made.
  // They can be just stored in std::vector, with custom insertion based
  // on binary search.
 
  set<G4VertexInfo,G4VertexComparator> vertexListSorted;
  set<G4VertexInfo,G4VertexComparator>::iterator begin
     = vertexListSorted.begin(), end = vertexListSorted.end(), pos, it;
  G4ThreeVector p;
  G4VertexInfo value;
 
  fVertexList.clear();
  G4int size = fFacets.size();
 
  G4double kCarTolerance24 = kCarTolerance * kCarTolerance / 4.0;
  G4double kCarTolerance3 = 3 * kCarTolerance;
  vector<G4int> newIndex(100);
 
  for (G4int k = 0; k < size; ++k)
  {
    G4VFacet &facet = *fFacets[k];
    G4int max = facet.GetNumberOfVertices();
 
    for (G4int i = 0; i < max; ++i)
    {
      p = facet.GetVertex(i);
      value.id = fVertexList.size();
      value.mag2 = p.x() + p.y() + p.z();
 
      G4bool found = false;
      G4int id = 0;
      if (!OutsideOfExtent(p, kCarTolerance))
      {
        pos = vertexListSorted.lower_bound(value);
        it = pos;
        while (it != end)    // Loop checking, 13.08.2015, G.Cosmo
        {
          id = (*it).id;
          G4ThreeVector q = fVertexList[id];
          G4double dif = (q-p).mag2();
          found = (dif < kCarTolerance24);
          if (found) break;
          dif = q.x() + q.y() + q.z() - value.mag2;
          if (dif > kCarTolerance3) break;
          it++;
        }
 
        if (!found && (fVertexList.size() > 1))
        {
          it = pos;
          while (it != begin)    // Loop checking, 13.08.2015, G.Cosmo
          {
            --it;
            id = (*it).id;
            G4ThreeVector q = fVertexList[id];
            G4double dif = (q-p).mag2();
            found = (dif < kCarTolerance24);
            if (found) break;
            dif = value.mag2 - (q.x() + q.y() + q.z());
            if (dif > kCarTolerance3) break;
          }
        }
      }
 
      if (!found)
      {
#ifdef G4SPECSDEBUG
        G4cout << p.x() << ":" << p.y() << ":" << p.z() << G4endl;
        G4cout << "Adding new vertex #" << i << " of facet " << k
               << " id " << value.id << G4endl;
        G4cout << "===" << G4endl;
#endif
        fVertexList.push_back(p);
        vertexListSorted.insert(value);
        begin = vertexListSorted.begin();
        end = vertexListSorted.end();
        newIndex[i] = value.id;
        //
        // Now update the maximum x, y and z limits of the volume.
        //
        if (value.id == 0) fMinExtent = fMaxExtent = p;
        else
        {
          if (p.x() > fMaxExtent.x()) fMaxExtent.setX(p.x());
          else if (p.x() < fMinExtent.x()) fMinExtent.setX(p.x());
          if (p.y() > fMaxExtent.y()) fMaxExtent.setY(p.y());
          else if (p.y() < fMinExtent.y()) fMinExtent.setY(p.y());
          if (p.z() > fMaxExtent.z()) fMaxExtent.setZ(p.z());
          else if (p.z() < fMinExtent.z()) fMinExtent.setZ(p.z());
        }
      }
      else
      {
#ifdef G4SPECSDEBUG
        G4cout << p.x() << ":" << p.y() << ":" << p.z() << G4endl;
        G4cout << "Vertex #" << i << " of facet " << k
               << " found, redirecting to " << id << G4endl;
        G4cout << "===" << G4endl;
#endif
        newIndex[i] = id;
      }
    }
    // only now it is possible to change vertices pointer
    //
    facet.SetVertices(&fVertexList);
    for (G4int i = 0; i < max; ++i)
      facet.SetVertexIndex(i,newIndex[i]);
  }
  vector<G4ThreeVector>(fVertexList).swap(fVertexList);
 
#ifdef G4SPECSDEBUG
  G4double previousValue = 0.;
  for (auto res=vertexListSorted.cbegin(); res!=vertexListSorted.cend(); ++res)
  {
    G4int id = (*res).id;
    G4ThreeVector vec = fVertexList[id];
    G4double mvalue = vec.x() + vec.y() + vec.z();
    if (previousValue && (previousValue - 1e-9 > mvalue))
      G4cout << "Error in CreateVertexList: previousValue " << previousValue
             <<  " is smaller than mvalue " << mvalue << G4endl;
    previousValue = mvalue;
  }
#endif
}

References fFacets, fMaxExtent, fMinExtent, fVertexList, G4cout, G4endl, G4VFacet::GetNumberOfVertices(), G4VFacet::GetVertex(), G4VertexInfo::id, G4VSolid::kCarTolerance, G4VertexInfo::mag2, G4INCL::Math::max(), OutsideOfExtent(), pos, G4VFacet::SetVertexIndex(), G4VFacet::SetVertices(), CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by SetSolidClosed().

◆ DeleteObjects()

void G4TessellatedSolid::DeleteObjects ( )

private

Definition at line 175 of file G4TessellatedSolid.cc.

{
  G4int size = fFacets.size();
  for (G4int i = 0; i < size; ++i)  { delete fFacets[i]; }
  fFacets.clear();
  delete fpPolyhedron; fpPolyhedron = nullptr;
}

References fFacets, and fpPolyhedron.

Referenced by operator=(), and ~G4TessellatedSolid().

◆ DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1921 of file G4TessellatedSolid.cc.

{
  scene.AddSolid (*this);
}

References G4VGraphicsScene::AddSolid().

Referenced by G4GenericTrap::DescribeYourselfTo().

◆ DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory ( )

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

References AllocatedMemory(), AllocatedMemoryWithoutVoxels(), G4cout, and G4endl.

Referenced by SetSolidClosed().

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1829 of file G4TessellatedSolid.cc.

{
  return SafetyFromOutside(p, false);
}

References SafetyFromOutside().

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

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

References DistanceToInCore(), G4endl, G4Exception(), G4VSolid::GetName(), Inside(), JustWarning, kInfinity, and kSurface.

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

◆ DistanceToInCandidates()

G4double G4TessellatedSolid::DistanceToInCandidates	(	const std::vector< G4int > &	candidates,
		const G4ThreeVector &	aPoint,
		const G4ThreeVector &	aDirection
	)		const

private

Definition at line 1482 of file G4TessellatedSolid.cc.

{
  G4int candidatesCount = candidates.size();
  G4double dist            = 0.0;
  G4double distFromSurface = 0.0;
  G4ThreeVector normal;
 
  G4double minDistance = kInfinity;
  for (G4int i = 0 ; i < candidatesCount; ++i)
  {
    G4int candidate = candidates[i];
    G4VFacet& facet = *fFacets[candidate];
    if (facet.Intersect(aPoint,direction,false,dist,distFromSurface,normal))
    {
      //
      // Set minDist to the new distance to current facet if distFromSurface is
      // in positive direction and point is not at surface. If the point is
      // within 0.5*kCarTolerance of the surface, then force distance to be
      // zero and leave member function immediately (for efficiency), as
      // proposed by & credit to Akira Okumura.
      //
      if ( (distFromSurface > kCarToleranceHalf)
        && (dist >= 0.0) && (dist < minDistance))
      {
        minDistance  = dist;
      }
      else
      {
        if (-kCarToleranceHalf <= dist && dist <= kCarToleranceHalf)
        {
         return 0.0;
        }
        else if  (distFromSurface > -kCarToleranceHalf
               && distFromSurface <  kCarToleranceHalf)
        {
          minDistance = dist;
        }
      }
    }
  }
  return minDistance;
}

References fFacets, G4VFacet::Intersect(), kCarToleranceHalf, kInfinity, and CLHEP::normal().

Referenced by DistanceToInCore().

◆ DistanceToInCore()

G4double G4TessellatedSolid::DistanceToInCore	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4double	aPstep = `kInfinity`
	)		const

private

Definition at line 1531 of file G4TessellatedSolid.cc.

{
  G4double minDistance;
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    minDistance = kInfinity;
    G4ThreeVector currentPoint = aPoint;
    G4ThreeVector direction = aDirection.unit();
    G4double shift = fVoxels.DistanceToFirst(currentPoint, direction);
    if (shift == kInfinity) return shift;
    G4double shiftBonus = kCarTolerance;
    if (shift)
      currentPoint += direction * (shift + shiftBonus);
    // if (!fVoxels.Contains(currentPoint))  return minDistance;
    G4double totalShift = shift;
 
    // G4SurfBits exclusion; // (1/*fVoxels.GetBitsPerSlice()*/);
    vector<G4int> curVoxel(3);
 
    fVoxels.GetVoxel(curVoxel, currentPoint);
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      const vector<G4int>& candidates = fVoxels.GetCandidates(curVoxel);
      if (candidates.size())
      {
        G4double distance=DistanceToInCandidates(candidates, aPoint, direction);
        if (minDistance > distance) minDistance = distance;
        if (distance < totalShift) break;
      }
 
      shift = fVoxels.DistanceToNext(currentPoint, direction, curVoxel);
      if (shift == kInfinity /*|| shift == 0*/) break;
 
      totalShift += shift;
      if (minDistance < totalShift) break;
 
      currentPoint += direction * (shift + shiftBonus);
    }
    while (fVoxels.UpdateCurrentVoxel(currentPoint, direction, curVoxel));
  }
  else
  {
    minDistance = DistanceToInNoVoxels(aPoint, aDirection, aPstep);
  }
 
  return minDistance;
}

References G4Voxelizer::DistanceToFirst(), DistanceToInCandidates(), DistanceToInNoVoxels(), G4Voxelizer::DistanceToNext(), fVoxels, G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4Voxelizer::GetVoxel(), G4VSolid::kCarTolerance, kInfinity, CLHEP::Hep3Vector::unit(), and G4Voxelizer::UpdateCurrentVoxel().

Referenced by DistanceToIn().

◆ DistanceToInNoVoxels()

G4double G4TessellatedSolid::DistanceToInNoVoxels	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4double	aPstep = `kInfinity`
	)		const

private

Definition at line 1233 of file G4TessellatedSolid.cc.

{
  G4double minDist         = kInfinity;
  G4double dist            = 0.0;
  G4double distFromSurface = 0.0;
  G4ThreeVector normal;
 
#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,v)",
                "GeomSolids1002", JustWarning, message);
  }
#endif
 
  G4int size = fFacets.size();
  for (G4int i = 0; i < size; ++i)
  {
    G4VFacet& facet = *fFacets[i];
    if (facet.Intersect(p,v,false,dist,distFromSurface,normal))
    {
      //
      // set minDist to the new distance to current facet if distFromSurface
      // is in positive direction and point is not at surface. If the point is
      // within 0.5*kCarTolerance of the surface, then force distance to be
      // zero and leave member function immediately (for efficiency), as
      // proposed by & credit to Akira Okumura.
      //
      if (distFromSurface > kCarToleranceHalf && dist >= 0.0 && dist < minDist)
      {
        minDist  = dist;
      }
      else
      {
        if (-kCarToleranceHalf <= dist && dist <= kCarToleranceHalf)
        {
          return 0.0;
        }
        else
        {
          if  (distFromSurface > -kCarToleranceHalf
            && distFromSurface <  kCarToleranceHalf)
          {
            minDist = dist;
          }
        }
      }
    }
  }
  return minDist;
}

References DistanceToOut(), fFacets, G4endl, G4Exception(), Inside(), G4VFacet::Intersect(), JustWarning, kCarToleranceHalf, kInfinity, kInside, mm, CLHEP::normal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToInCore().

◆ DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1864 of file G4TessellatedSolid.cc.

{
  return SafetyFromInside(p, false);
}

References SafetyFromInside().

Referenced by DistanceToInNoVoxels(), 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 1887 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;
}

References DistanceToOutCore(), G4endl, G4Exception(), G4VSolid::GetName(), Inside(), JustWarning, kInfinity, kSurface, and CLHEP::detail::n.

◆ DistanceToOutCandidates()

void G4TessellatedSolid::DistanceToOutCandidates	(	const std::vector< G4int > &	candidates,
		const G4ThreeVector &	aPoint,
		const G4ThreeVector &	direction,
		G4double &	minDist,
		G4ThreeVector &	minNormal,
		G4int &	minCandidate
	)		const

private

Definition at line 1369 of file G4TessellatedSolid.cc.

{
  G4int candidatesCount = candidates.size();
  G4double dist            = 0.0;
  G4double distFromSurface = 0.0;
  G4ThreeVector normal;
 
  for (G4int i = 0 ; i < candidatesCount; ++i)
  {
    G4int candidate = candidates[i];
    G4VFacet& facet = *fFacets[candidate];
    if (facet.Intersect(aPoint,direction,true,dist,distFromSurface,normal))
    {
      if (distFromSurface > 0.0 && distFromSurface <= kCarToleranceHalf
       && facet.Distance(aPoint,kCarTolerance) <= kCarToleranceHalf)
      {
        // We are on a surface
        //
        minDist = 0.0;
        minNormal = normal;
        minCandidate = candidate;
        break;
      }
      if (dist >= 0.0 && dist < minDist)
      {
        minDist = dist;
        minNormal = normal;
        minCandidate = candidate;
      }
    }
  }
}

References G4VFacet::Distance(), fFacets, G4VFacet::Intersect(), G4VSolid::kCarTolerance, kCarToleranceHalf, and CLHEP::normal().

Referenced by DistanceToOutCore().

◆ DistanceToOutCore()

G4double G4TessellatedSolid::DistanceToOutCore	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4ThreeVector &	aNormalVector,
		G4bool &	aConvex,
		G4double	aPstep = `kInfinity`
	)		const

private

Definition at line 1410 of file G4TessellatedSolid.cc.

{
  G4double minDistance;
 
  if (fVoxels.GetCountOfVoxels() > 1)
  {
    minDistance = kInfinity;
 
    G4ThreeVector currentPoint = aPoint;
    G4ThreeVector direction = aDirection.unit();
    G4double totalShift = 0.;
    vector<G4int> curVoxel(3);
    if (!fVoxels.Contains(aPoint)) return 0.;
 
    fVoxels.GetVoxel(curVoxel, currentPoint);
 
    G4double shiftBonus = kCarTolerance;
 
    const vector<G4int>* old = nullptr;
 
    G4int minCandidate = -1;
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      const vector<G4int>& candidates = fVoxels.GetCandidates(curVoxel);
      if (old == &candidates)
        ++old;
      if (old != &candidates && candidates.size())
      {
        DistanceToOutCandidates(candidates, aPoint, direction, minDistance,
                                aNormalVector, minCandidate);
        if (minDistance <= totalShift) break;
      }
 
      G4double shift=fVoxels.DistanceToNext(currentPoint, direction, curVoxel);
      if (shift == kInfinity) break;
 
      totalShift += shift;
      if (minDistance <= totalShift) break;
 
      currentPoint += direction * (shift + shiftBonus);
 
      old = &candidates;
    }
    while (fVoxels.UpdateCurrentVoxel(currentPoint, direction, curVoxel));
 
    if (minCandidate < 0)
    {
      // No intersection found
      minDistance = 0.;
      aConvex = false;
      Normal(aPoint, aNormalVector);
    }
    else
    {
      aConvex = (fExtremeFacets.find(fFacets[minCandidate])
              != fExtremeFacets.end());
    }
  }
  else
  {
    minDistance = DistanceToOutNoVoxels(aPoint, aDirection, aNormalVector,
                                        aConvex, aPstep);
  }
  return minDistance;
}

References G4Voxelizer::Contains(), G4Voxelizer::DistanceToNext(), DistanceToOutCandidates(), DistanceToOutNoVoxels(), fExtremeFacets, fFacets, fVoxels, G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4Voxelizer::GetVoxel(), G4VSolid::kCarTolerance, kInfinity, Normal(), CLHEP::Hep3Vector::unit(), and G4Voxelizer::UpdateCurrentVoxel().

Referenced by DistanceToOut().

◆ DistanceToOutNoVoxels()

G4double G4TessellatedSolid::DistanceToOutNoVoxels	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4ThreeVector &	aNormalVector,
		G4bool &	aConvex,
		G4double	aPstep = `kInfinity`
	)		const

private

Definition at line 1299 of file G4TessellatedSolid.cc.

{
  G4double minDist         = kInfinity;
  G4double dist            = 0.0;
  G4double distFromSurface = 0.0;
  G4ThreeVector normal, minNormal;
 
#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
 
  G4bool isExtreme = false;
  G4int size = fFacets.size();
  for (G4int i = 0; i < size; ++i)
  {
    G4VFacet& facet = *fFacets[i];
    if (facet.Intersect(p,v,true,dist,distFromSurface,normal))
    {
      if (distFromSurface > 0.0 && distFromSurface <= kCarToleranceHalf
        && facet.Distance(p,kCarTolerance) <= kCarToleranceHalf)
      {
        // We are on a surface. Return zero.
        aConvex = (fExtremeFacets.find(&facet) != fExtremeFacets.end());
        // Normal(p, aNormalVector);
        // aNormalVector = facet.GetSurfaceNormal();
        aNormalVector = normal;
        return 0.0;
      }
      if (dist >= 0.0 && dist < minDist)
      {
        minDist   = dist;
        minNormal = normal;
        isExtreme = (fExtremeFacets.find(&facet) != fExtremeFacets.end());
      }
    }
  }
  if (minDist < kInfinity)
  {
    aNormalVector = minNormal;
    aConvex = isExtreme;
    return minDist;
  }
  else
  {
    // No intersection found
    aConvex = false;
    Normal(p, aNormalVector);
    return 0.0;
  }
}

References G4VFacet::Distance(), DistanceToIn(), fExtremeFacets, fFacets, G4endl, G4Exception(), Inside(), G4VFacet::Intersect(), JustWarning, G4VSolid::kCarTolerance, kCarToleranceHalf, kInfinity, kOutside, mm, Normal(), CLHEP::normal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOutCore().

◆ DumpInfo()

void G4VSolid::DumpInfo ( ) const

inlineinherited

◆ EstimateCubicVolume()

G4double G4VSolid::EstimateCubicVolume	(	G4int	nStat,
		G4double	epsilon
	)		const

inherited

Definition at line 203 of file G4VSolid.cc.

{
  G4int iInside=0;
  G4double px,py,pz,minX,maxX,minY,maxY,minZ,maxZ,volume,halfepsilon;
  G4ThreeVector p;
  EInside in;
 
  // values needed for CalculateExtent signature
 
  G4VoxelLimits limit;                // Unlimited
  G4AffineTransform origin;
 
  // min max extents of pSolid along X,Y,Z
 
  CalculateExtent(kXAxis,limit,origin,minX,maxX);
  CalculateExtent(kYAxis,limit,origin,minY,maxY);
  CalculateExtent(kZAxis,limit,origin,minZ,maxZ);
 
  // limits
 
  if(nStat < 100)    nStat   = 100;
  if(epsilon > 0.01) epsilon = 0.01;
  halfepsilon = 0.5*epsilon;
 
  for(auto i = 0; i < nStat; ++i )
  {
    px = minX-halfepsilon+(maxX-minX+epsilon)*G4QuickRand();
    py = minY-halfepsilon+(maxY-minY+epsilon)*G4QuickRand();
    pz = minZ-halfepsilon+(maxZ-minZ+epsilon)*G4QuickRand();
    p  = G4ThreeVector(px,py,pz);
    in = Inside(p);
    if(in != kOutside) ++iInside;
  }
  volume = (maxX-minX+epsilon)*(maxY-minY+epsilon)
         * (maxZ-minZ+epsilon)*iInside/nStat;
  return volume;
}

References G4VSolid::CalculateExtent(), epsilon(), G4QuickRand(), G4VSolid::Inside(), kOutside, kXAxis, kYAxis, kZAxis, and maxZ.

Referenced by G4VSolid::GetCubicVolume(), G4BooleanSolid::GetCubicVolume(), and G4VCSGfaceted::GetCubicVolume().

◆ EstimateSurfaceArea()

G4double G4VSolid::EstimateSurfaceArea	(	G4int	nStat,
		G4double	ell
	)		const

inherited

Definition at line 265 of file G4VSolid.cc.

{
  static const G4double s2 = 1./std::sqrt(2.);
  static const G4double s3 = 1./std::sqrt(3.);
  static const G4ThreeVector directions[64] =
  {
    G4ThreeVector(  0,  0,  0), G4ThreeVector( -1,  0,  0), // (  ,  ,  ) ( -,  ,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,  ) (-+,  ,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,  ) ( -, -,  )
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,  ) (-+, -,  )
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,  ) ( -, +,  )
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,  ) (-+, +,  )
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,  ) ( -,-+,  )
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,  ) (-+,-+,  )
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,  , -) ( -,  , -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,  , -) (-+,  , -)
    G4ThreeVector(  0,-s2,-s2), G4ThreeVector(-s3,-s3,-s3), // (  , -, -) ( -, -, -)
    G4ThreeVector( s3,-s3,-s3), G4ThreeVector(  0,-s2,-s2), // ( +, -, -) (-+, -, -)
 
    G4ThreeVector(  0, s2,-s2), G4ThreeVector(-s3, s3,-s3), // (  , +, -) ( -, +, -)
    G4ThreeVector( s3, s3,-s3), G4ThreeVector(  0, s2,-s2), // ( +, +, -) (-+, +, -)
    G4ThreeVector(  0,  0, -1), G4ThreeVector(-s2,  0,-s2), // (  ,-+, -) ( -,-+, -)
    G4ThreeVector( s2,  0,-s2), G4ThreeVector(  0,  0, -1), // ( +,-+, -) (-+,-+, -)
 
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,  , +) ( -,  , +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,  , +) (-+,  , +)
    G4ThreeVector(  0,-s2, s2), G4ThreeVector(-s3,-s3, s3), // (  , -, +) ( -, -, +)
    G4ThreeVector( s3,-s3, s3), G4ThreeVector(  0,-s2, s2), // ( +, -, +) (-+, -, +)
 
    G4ThreeVector(  0, s2, s2), G4ThreeVector(-s3, s3, s3), // (  , +, +) ( -, +, +)
    G4ThreeVector( s3, s3, s3), G4ThreeVector(  0, s2, s2), // ( +, +, +) (-+, +, +)
    G4ThreeVector(  0,  0,  1), G4ThreeVector(-s2,  0, s2), // (  ,-+, +) ( -,-+, +)
    G4ThreeVector( s2,  0, s2), G4ThreeVector(  0,  0,  1), // ( +,-+, +) (-+,-+, +)
 
    G4ThreeVector(  0,  0, -1), G4ThreeVector( -1,  0,  0), // (  ,  ,-+) ( -,  ,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,  ,-+) (-+,  ,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector(-s2,-s2,  0), // (  , -,-+) ( -, -,-+)
    G4ThreeVector( s2, -s2, 0), G4ThreeVector(  0, -1,  0), // ( +, -,-+) (-+, -,-+)
 
    G4ThreeVector(  0,  1,  0), G4ThreeVector( -s2, s2, 0), // (  , +,-+) ( -, +,-+)
    G4ThreeVector( s2, s2,  0), G4ThreeVector(  0,  1,  0), // ( +, +,-+) (-+, +,-+)
    G4ThreeVector(  0, -1,  0), G4ThreeVector( -1,  0,  0), // (  ,-+,-+) ( -,-+,-+)
    G4ThreeVector(  1,  0,  0), G4ThreeVector( -1,  0,  0), // ( +,-+,-+) (-+,-+,-+)
  };
 
  G4ThreeVector bmin, bmax;
  BoundingLimits(bmin, bmax);
 
  G4double dX = bmax.x() - bmin.x();
  G4double dY = bmax.y() - bmin.y();
  G4double dZ = bmax.z() - bmin.z();
 
  // Define statistics and shell thickness
  //
  G4int npoints = (nstat < 1000) ? 1000 : nstat;
  G4double coeff = 0.5 / std::cbrt(G4double(npoints));
  G4double eps = (ell > 0) ? ell : coeff * std::min(std::min(dX, dY), dZ);
  G4double del = 1.8 * eps; // shold be more than sqrt(3.)
 
  G4double minX = bmin.x() - eps;
  G4double minY = bmin.y() - eps;
  G4double minZ = bmin.z() - eps;
 
  G4double dd = 2. * eps;
  dX += dd;
  dY += dd;
  dZ += dd;
 
  // Calculate surface area
  //
  G4int icount = 0;
  for(auto i = 0; i < npoints; ++i)
  {
    G4double px = minX + dX*G4QuickRand();
    G4double py = minY + dY*G4QuickRand();
    G4double pz = minZ + dZ*G4QuickRand();
    G4ThreeVector p  = G4ThreeVector(px, py, pz);
    EInside in = Inside(p);
    G4double dist = 0;
    if (in == kInside)
    {
      if (DistanceToOut(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kInside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kInside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kInside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kInside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kInside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kInside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToOut(p, v);
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= v.dot(n);
    }
    else if (in == kOutside)
    {
      if (DistanceToIn(p) >= eps) continue;
      G4int icase = 0;
      if (Inside(G4ThreeVector(px-del, py, pz)) != kOutside) icase += 1;
      if (Inside(G4ThreeVector(px+del, py, pz)) != kOutside) icase += 2;
      if (Inside(G4ThreeVector(px, py-del, pz)) != kOutside) icase += 4;
      if (Inside(G4ThreeVector(px, py+del, pz)) != kOutside) icase += 8;
      if (Inside(G4ThreeVector(px, py, pz-del)) != kOutside) icase += 16;
      if (Inside(G4ThreeVector(px, py, pz+del)) != kOutside) icase += 32;
      if (icase == 0) continue;
      G4ThreeVector v = directions[icase];
      dist = DistanceToIn(p, v);
      if (dist == kInfinity) continue;
      G4ThreeVector n = SurfaceNormal(p + v*dist);
      dist *= -(v.dot(n));
    }
    if (dist < eps) ++icount;
  }
  return dX*dY*dZ*icount/npoints/dd;
}

References G4VSolid::BoundingLimits(), G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), CLHEP::Hep3Vector::dot(), eps, G4QuickRand(), G4VSolid::Inside(), kInfinity, kInside, kOutside, G4INCL::Math::min(), CLHEP::detail::n, G4VSolid::SurfaceNormal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4VSolid::GetSurfaceArea(), G4MultiUnion::GetSurfaceArea(), and G4VCSGfaceted::GetSurfaceArea().

◆ GetConstituentSolid() [1/2]

G4VSolid * G4VSolid::GetConstituentSolid ( G4int no )

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 170 of file G4VSolid.cc.

171{ return nullptr; }

◆ GetConstituentSolid() [2/2]

const G4VSolid * G4VSolid::GetConstituentSolid ( G4int no ) const

virtualinherited

Reimplemented in G4BooleanSolid.

Definition at line 167 of file G4VSolid.cc.

168{ return nullptr; }

Referenced by G4BooleanSolid::StackPolyhedron().

◆ GetCubicVolume()

G4double G4TessellatedSolid::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

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

References CLHEP::Hep3Vector::dot(), fCubicVolume, fFacets, G4VFacet::GetArea(), G4VFacet::GetSurfaceNormal(), and G4VFacet::GetVertex().

◆ GetDisplacedSolidPtr() [1/2]

G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( )

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 176 of file G4VSolid.cc.

177{ return nullptr; }

◆ GetDisplacedSolidPtr() [2/2]

const G4DisplacedSolid * G4VSolid::GetDisplacedSolidPtr ( ) const

virtualinherited

Reimplemented in G4DisplacedSolid.

Definition at line 173 of file G4VSolid.cc.

174{ return nullptr; }

◆ GetEntityType()

G4GeometryType G4TessellatedSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1753 of file G4TessellatedSolid.cc.

{
  return fGeometryType;
}

References fGeometryType.

◆ GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 2113 of file G4TessellatedSolid.cc.

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

References fMaxExtent, fMinExtent, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GenericTrap::GetExtent().

◆ GetFacet()

G4VFacet * G4TessellatedSolid::GetFacet ( G4int i ) const

inline

Definition at line 304 of file G4TessellatedSolid.hh.

{
  return fFacets[i];
}

References fFacets.

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

◆ GetFacetIndex()

G4int G4TessellatedSolid::GetFacetIndex ( const G4ThreeVector & p ) const

Definition at line 1105 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 = 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;
    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;
        index = i;
      }
    }
  }
  return index;
}

References G4VFacet::Distance(), fFacets, fVoxels, G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4Voxelizer::GetVoxel(), kCarToleranceHalf, and kInfinity.

◆ GetMaxXExtent()

G4double G4TessellatedSolid::GetMaxXExtent ( ) const

Definition at line 2078 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.x();
}

References fMaxExtent, and CLHEP::Hep3Vector::x().

Referenced by G4ExtrudedSolid::Inside().

◆ GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent ( ) const

Definition at line 2092 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.y();
}

References fMaxExtent, and CLHEP::Hep3Vector::y().

Referenced by G4ExtrudedSolid::Inside().

◆ GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent ( ) const

Definition at line 2106 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.z();
}

References fMaxExtent, and CLHEP::Hep3Vector::z().

Referenced by G4ExtrudedSolid::Inside().

◆ GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent ( ) const

Definition at line 2071 of file G4TessellatedSolid.cc.

{
  return fMinExtent.x();
}

References fMinExtent, and CLHEP::Hep3Vector::x().

Referenced by G4ExtrudedSolid::Inside().

◆ GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent ( ) const

Definition at line 2085 of file G4TessellatedSolid.cc.

{
  return fMinExtent.y();
}

References fMinExtent, and CLHEP::Hep3Vector::y().

Referenced by G4ExtrudedSolid::Inside().

◆ GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent ( ) const

Definition at line 2099 of file G4TessellatedSolid.cc.

{
  return fMinExtent.z();
}

References fMinExtent, and CLHEP::Hep3Vector::z().

Referenced by G4ExtrudedSolid::Inside().

◆ GetName()

G4String G4VSolid::GetName ( ) const

inlineinherited

◆ GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets ( ) const

Definition at line 761 of file G4TessellatedSolid.cc.

{
  return fFacets.size();
}

References fFacets.

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

◆ GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

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

References fFacets, and G4INCL::DeJongSpin::shoot().

Referenced by G4GenericTrap::GetPointOnSurface().

◆ GetPolyhedron()

G4Polyhedron * G4TessellatedSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

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

References CreatePolyhedron(), fpPolyhedron, fRebuildPolyhedron, HepPolyhedron::GetNumberOfRotationSteps(), G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation(), anonymous_namespace{G4TessellatedSolid.cc}::polyhedronMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by G4GenericTrap::GetPolyhedron().

◆ GetSolidClosed()

G4bool G4TessellatedSolid::GetSolidClosed ( ) const

Definition at line 662 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

References fSolidClosed.

◆ GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

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

References fFacets, fSurfaceArea, and G4VFacet::GetArea().

◆ GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

Referenced by G4NavigationLogger::CheckDaughterEntryPoint(), G4ParameterisedNavigation::ComputeStep(), G4NavigationLogger::PreComputeStepLog(), G4NavigationLogger::ReportOutsideMother(), and G4NavigationLogger::ReportVolumeAndIntersection().

◆ GetVoxels()

G4Voxelizer & G4TessellatedSolid::GetVoxels ( )

inline

Definition at line 314 of file G4TessellatedSolid.hh.

{
  return fVoxels;
}

References fVoxels.

◆ Initialize()

void G4TessellatedSolid::Initialize ( )

private

Definition at line 157 of file G4TessellatedSolid.cc.

{
  kCarToleranceHalf = 0.5*kCarTolerance;
 
  fRebuildPolyhedron = false; fpPolyhedron = nullptr;
  fCubicVolume = 0.; fSurfaceArea = 0.;
 
  fGeometryType = "G4TessellatedSolid";
  fSolidClosed  = false;
 
  fMinExtent.set(kInfinity,kInfinity,kInfinity);
  fMaxExtent.set(-kInfinity,-kInfinity,-kInfinity);
 
  SetRandomVectors();
}

References fCubicVolume, fGeometryType, fMaxExtent, fMinExtent, fpPolyhedron, fRebuildPolyhedron, fSolidClosed, fSurfaceArea, G4VSolid::kCarTolerance, kCarToleranceHalf, kInfinity, CLHEP::Hep3Vector::set(), and SetRandomVectors().

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

◆ Inside()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1798 of file G4TessellatedSolid.cc.

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

References fVoxels, G4Voxelizer::GetCountOfVoxels(), InsideNoVoxels(), and InsideVoxels().

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

◆ InsideNoVoxels()

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

private

Definition at line 959 of file G4TessellatedSolid.cc.

{
  //
  // First the simple test - check if we're outside of the X-Y-Z extremes
  // of the tessellated solid.
  //
  if (OutsideOfExtent(p, kCarTolerance))
    return kOutside;
 
  const G4double dirTolerance = 1.0E-14;
 
  G4double minDist = kInfinity;
  //
  // Check if we are close to a surface
  //
  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;
    if (dist <= kCarToleranceHalf)
    {
      return kSurface;
    }
  }
  //
  // The following is something of an adaptation of the method implemented by
  // Rickard Holmberg augmented with information from Schneider & Eberly,
  // "Geometric Tools for Computer Graphics," pp700-701, 2003. In essence, we're
  // trying to determine whether we're inside the volume by projecting a few
  // rays and determining if the first surface crossed is has a normal vector
  // between 0 to pi/2 (out-going) or pi/2 to pi (in-going). We should also
  // avoid rays which are nearly within the plane of the tessellated surface,
  // and therefore produce rays randomly. For the moment, this is a bit
  // over-engineered (belt-braces-and-ducttape).
  //
#if G4SPECSDEBUG
  G4int nTry                = 7;
#else
  G4int nTry                = 3;
#endif
  G4double distOut          = kInfinity;
  G4double distIn           = kInfinity;
  G4double distO            = 0.0;
  G4double distI            = 0.0;
  G4double distFromSurfaceO = 0.0;
  G4double distFromSurfaceI = 0.0;
  G4ThreeVector normalO(0.0,0.0,0.0);
  G4ThreeVector normalI(0.0,0.0,0.0);
  G4bool crossingO          = false;
  G4bool crossingI          = false;
  EInside location          = kOutside;
  EInside locationprime     = kOutside;
  G4int sm = 0;
 
  for (G4int i=0; i<nTry; ++i)
  {
    G4bool nearParallel = false;
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      //
      // We loop until we find direction where the vector is not nearly parallel
      // to the surface of any facet since this causes ambiguities.  The usual
      // case is that the angles should be sufficiently different, but there
      // are 20 random directions to select from - hopefully sufficient.
      //
      distOut = distIn = kInfinity;
      G4ThreeVector v = fRandir[sm];
      sm++;
      vector<G4VFacet*>::const_iterator f = fFacets.begin();
 
      do    // Loop checking, 13.08.2015, G.Cosmo
      {
        //
        // Here we loop through the facets to find out if there is an
        // intersection between the ray and that facet. The test if performed
        // separately whether the ray is entering the facet or exiting.
        //
        crossingO = ((*f)->Intersect(p,v,true,distO,distFromSurfaceO,normalO));
        crossingI = ((*f)->Intersect(p,v,false,distI,distFromSurfaceI,normalI));
        if (crossingO || crossingI)
        {
          nearParallel = (crossingO && std::fabs(normalO.dot(v))<dirTolerance)
                      || (crossingI && std::fabs(normalI.dot(v))<dirTolerance);
          if (!nearParallel)
          {
            if (crossingO && distO > 0.0 && distO < distOut) distOut = distO;
            if (crossingI && distI > 0.0 && distI < distIn)  distIn  = distI;
          }
        }
      } while (!nearParallel && ++f != fFacets.end());
    } while (nearParallel && sm != fMaxTries);
 
#ifdef G4VERBOSE
    if (sm == fMaxTries)
    {
      //
      // We've run out of random vector directions. If nTries is set
      // sufficiently low (nTries <= 0.5*maxTries) then this would indicate
      // that there is something wrong with geometry.
      //
      std::ostringstream message;
      G4int oldprc = message.precision(16);
      message << "Cannot determine whether point is inside or outside volume!"
        << G4endl
        << "Solid name       = " << GetName()  << G4endl
        << "Geometry Type    = " << fGeometryType  << G4endl
        << "Number of facets = " << fFacets.size() << G4endl
        << "Position:"  << G4endl << G4endl
        << "p.x() = "   << p.x()/mm << " mm" << G4endl
        << "p.y() = "   << p.y()/mm << " mm" << G4endl
        << "p.z() = "   << p.z()/mm << " mm";
      message.precision(oldprc);
      G4Exception("G4TessellatedSolid::Inside()",
        "GeomSolids1002", JustWarning, message);
    }
#endif
    //
    // In the next if-then-elseif G4String the logic is as follows:
    // (1) You don't hit anything so cannot be inside volume, provided volume
    //     constructed correctly!
    // (2) Distance to inside (ie. nearest facet such that you enter facet) is
    //     shorter than distance to outside (nearest facet such that you exit
    //     facet) - on condition of safety distance - therefore we're outside.
    // (3) Distance to outside is shorter than distance to inside therefore
    // we're inside.
    //
    if (distIn == kInfinity && distOut == kInfinity)
      locationprime = kOutside;
    else if (distIn <= distOut - kCarToleranceHalf)
      locationprime = kOutside;
    else if (distOut <= distIn - kCarToleranceHalf)
      locationprime = kInside;
 
    if (i == 0) location = locationprime;
  }
 
  return location;
}

References G4VFacet::Distance(), CLHEP::Hep3Vector::dot(), fFacets, fGeometryType, fMaxTries, fRandir, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, G4VSolid::kCarTolerance, kCarToleranceHalf, kInfinity, kInside, kOutside, kSurface, mm, OutsideOfExtent(), G4InuclParticleNames::sm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by Inside(), and PrecalculateInsides().

◆ InsideVoxels()

EInside G4TessellatedSolid::InsideVoxels ( const G4ThreeVector & aPoint ) const

private

Definition at line 768 of file G4TessellatedSolid.cc.

{
  //
  // First the simple test - check if we're outside of the X-Y-Z extremes
  // of the tessellated solid.
  //
  if (OutsideOfExtent(p, kCarTolerance))
    return kOutside;
 
  vector<G4int> startingVoxel(3);
  fVoxels.GetVoxel(startingVoxel, p);
 
  const G4double dirTolerance = 1.0E-14;
 
  const vector<G4int> &startingCandidates =
    fVoxels.GetCandidates(startingVoxel);
  G4int limit = startingCandidates.size();
  if (limit == 0 && fInsides.GetNbits())
  {
    G4int index = fVoxels.GetPointIndex(p);
    EInside location = fInsides[index] ? kInside : kOutside;
    return location;
  }
 
  G4double minDist = kInfinity;
 
  for(G4int i = 0; i < limit; ++i)
  {
    G4int candidate = startingCandidates[i];
    G4VFacet &facet = *fFacets[candidate];
    G4double dist = facet.Distance(p,minDist);
    if (dist < minDist) minDist = dist;
    if (dist <= kCarToleranceHalf)
      return kSurface;
  }
 
  // The following is something of an adaptation of the method implemented by
  // Rickard Holmberg augmented with information from Schneider & Eberly,
  // "Geometric Tools for Computer Graphics," pp700-701, 2003. In essence,
  // we're trying to determine whether we're inside the volume by projecting
  // a few rays and determining if the first surface crossed is has a normal
  // vector between 0 to pi/2 (out-going) or pi/2 to pi (in-going).
  // We should also avoid rays which are nearly within the plane of the
  // tessellated surface, and therefore produce rays randomly.
  // For the moment, this is a bit over-engineered (belt-braces-and-ducttape).
  //
  G4double distOut          = kInfinity;
  G4double distIn           = kInfinity;
  G4double distO            = 0.0;
  G4double distI            = 0.0;
  G4double distFromSurfaceO = 0.0;
  G4double distFromSurfaceI = 0.0;
  G4ThreeVector normalO, normalI;
  G4bool crossingO          = false;
  G4bool crossingI          = false;
  EInside location          = kOutside;
  G4int sm                  = 0;
 
  G4bool nearParallel = false;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    // We loop until we find direction where the vector is not nearly parallel
    // to the surface of any facet since this causes ambiguities.  The usual
    // case is that the angles should be sufficiently different, but there
    // are 20 random directions to select from - hopefully sufficient.
    //
    distOut = distIn = kInfinity;
    const G4ThreeVector& v = fRandir[sm];
    ++sm;
    //
    // This code could be voxelized by the same algorithm, which is used for
    // DistanceToOut(). We will traverse through fVoxels. we will call
    // intersect only for those, which would be candidates and was not
    // checked before.
    //
    G4ThreeVector currentPoint = p;
    G4ThreeVector direction = v.unit();
    // G4SurfBits exclusion(fVoxels.GetBitsPerSlice());
    vector<G4int> curVoxel(3);
    curVoxel = startingVoxel;
    G4double shiftBonus = kCarTolerance;
 
    G4bool crossed = false;
    G4bool started = true;
 
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      const vector<G4int> &candidates =
        started ? startingCandidates : fVoxels.GetCandidates(curVoxel);
      started = false;
      if (G4int candidatesCount = candidates.size())
      {
        for (G4int i = 0 ; i < candidatesCount; ++i)
        {
          G4int candidate = candidates[i];
          // bits.SetBitNumber(candidate);
          G4VFacet& facet = *fFacets[candidate];
 
          crossingO = facet.Intersect(p,v,true,distO,distFromSurfaceO,normalO);
          crossingI = facet.Intersect(p,v,false,distI,distFromSurfaceI,normalI);
 
          if (crossingO || crossingI)
          {
            crossed = true;
 
            nearParallel = (crossingO
                     && std::fabs(normalO.dot(v))<dirTolerance)
                     || (crossingI && std::fabs(normalI.dot(v))<dirTolerance);
            if (!nearParallel)
            {
              if (crossingO && distO > 0.0 && distO < distOut)
                distOut = distO;
              if (crossingI && distI > 0.0 && distI < distIn)
                distIn  = distI;
            }
            else break;
          }
        }
        if (nearParallel) break;
      }
      else
      {
        if (!crossed)
        {
          G4int index = fVoxels.GetVoxelsIndex(curVoxel);
          G4bool inside = fInsides[index];
          location = inside ? kInside : kOutside;
          return location;
        }
      }
 
      G4double shift=fVoxels.DistanceToNext(currentPoint, direction, curVoxel);
      if (shift == kInfinity) break;
 
      currentPoint += direction * (shift + shiftBonus);
    }
    while (fVoxels.UpdateCurrentVoxel(currentPoint, direction, curVoxel));
 
  }
  while (nearParallel && sm != fMaxTries);
  //
  // Here we loop through the facets to find out if there is an intersection
  // between the ray and that facet.  The test if performed separately whether
  // the ray is entering the facet or exiting.
  //
#ifdef G4VERBOSE
  if (sm == fMaxTries)
  {
    //
    // We've run out of random vector directions. If nTries is set sufficiently
    // low (nTries <= 0.5*maxTries) then this would indicate that there is
    // something wrong with geometry.
    //
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Cannot determine whether point is inside or outside volume!"
      << G4endl
      << "Solid name       = " << GetName()  << G4endl
      << "Geometry Type    = " << fGeometryType  << G4endl
      << "Number of facets = " << fFacets.size() << G4endl
      << "Position:"  << G4endl << G4endl
      << "p.x() = "   << p.x()/mm << " mm" << G4endl
      << "p.y() = "   << p.y()/mm << " mm" << G4endl
      << "p.z() = "   << p.z()/mm << " mm";
    message.precision(oldprc);
    G4Exception("G4TessellatedSolid::Inside()",
                "GeomSolids1002", JustWarning, message);
  }
#endif
 
  // In the next if-then-elseif G4String the logic is as follows:
  // (1) You don't hit anything so cannot be inside volume, provided volume
  //     constructed correctly!
  // (2) Distance to inside (ie. nearest facet such that you enter facet) is
  //     shorter than distance to outside (nearest facet such that you exit
  //     facet) - on condition of safety distance - therefore we're outside.
  // (3) Distance to outside is shorter than distance to inside therefore
  //     we're inside.
  //
  if (distIn == kInfinity && distOut == kInfinity)
    location = kOutside;
  else if (distIn <= distOut - kCarToleranceHalf)
    location = kOutside;
  else if (distOut <= distIn - kCarToleranceHalf)
    location = kInside;
 
  return location;
}

References G4VFacet::Distance(), G4Voxelizer::DistanceToNext(), CLHEP::Hep3Vector::dot(), fFacets, fGeometryType, fInsides, fMaxTries, fRandir, fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCandidates(), G4VSolid::GetName(), G4SurfBits::GetNbits(), G4Voxelizer::GetPointIndex(), G4Voxelizer::GetVoxel(), G4Voxelizer::GetVoxelsIndex(), G4VFacet::Intersect(), JustWarning, G4VSolid::kCarTolerance, kCarToleranceHalf, kInfinity, kInside, kOutside, kSurface, mm, OutsideOfExtent(), G4InuclParticleNames::sm, CLHEP::Hep3Vector::unit(), G4Voxelizer::UpdateCurrentVoxel(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by Inside().

◆ MinDistanceFacet()

G4double G4TessellatedSolid::MinDistanceFacet	(	const G4ThreeVector &	p,
		G4bool	simple,
		G4VFacet *&	facet
	)		const

private

Definition at line 1594 of file G4TessellatedSolid.cc.

{
  G4double minDist = kInfinity;
 
  G4int size = fVoxels.GetVoxelBoxesSize();
  vector<pair<G4int, G4double> > voxelsSorted(size);
 
  pair<G4int, G4double> info;
 
  for (G4int i = 0; i < size; ++i)
  {
    const G4VoxelBox& voxelBox = fVoxels.GetVoxelBox(i);
 
    G4ThreeVector pointShifted = p - voxelBox.pos;
    G4double safety = fVoxels.MinDistanceToBox(pointShifted, voxelBox.hlen);
    info.first = i;
    info.second = safety;
    voxelsSorted[i] = info;
  }
 
  std::sort(voxelsSorted.begin(), voxelsSorted.end(),
            &G4TessellatedSolid::CompareSortedVoxel);
 
  for (G4int i = 0; i < size; ++i)
  {
    const pair<G4int,G4double>& inf = voxelsSorted[i];
    G4double dist = inf.second;
    if (dist > minDist) break;
 
    const vector<G4int>& candidates = fVoxels.GetVoxelBoxCandidates(inf.first);
    G4int csize = candidates.size();
    for (G4int j = 0; j < csize; ++j)
    {
      G4int candidate = candidates[j];
      G4VFacet& facet = *fFacets[candidate];
      dist = simple ? facet.Distance(p,minDist)
                    : facet.Distance(p,minDist,false);
      if (dist < minDist)
      {
        minDist  = dist;
        minFacet = &facet;
      }
    }
  }
  return minDist;
}

References CompareSortedVoxel(), G4VFacet::Distance(), fFacets, fVoxels, G4Voxelizer::GetVoxelBox(), G4Voxelizer::GetVoxelBoxCandidates(), G4Voxelizer::GetVoxelBoxesSize(), G4VoxelBox::hlen, kInfinity, G4Voxelizer::MinDistanceToBox(), and G4VoxelBox::pos.

Referenced by Normal(), SafetyFromInside(), and SafetyFromOutside().

◆ Normal()

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

virtual

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

References G4VFacet::Distance(), fFacets, fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4VFacet::GetSurfaceNormal(), G4Voxelizer::GetVoxel(), JustWarning, kCarToleranceHalf, kInfinity, MinDistanceFacet(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOutCore(), DistanceToOutNoVoxels(), and SurfaceNormal().

◆ operator+=()

G4TessellatedSolid & G4TessellatedSolid::operator+= ( const G4TessellatedSolid & right )

Definition at line 748 of file G4TessellatedSolid.cc.

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

References AddFacet(), G4VFacet::GetClone(), GetFacet(), and GetNumberOfFacets().

◆ operator=()

G4TessellatedSolid & G4TessellatedSolid::operator= ( const G4TessellatedSolid & right )

Definition at line 139 of file G4TessellatedSolid.cc.

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

References CopyObjects(), DeleteObjects(), Initialize(), G4VSolid::operator=(), and geant4_check_module_cycles::ts.

Referenced by G4ExtrudedSolid::operator=().

◆ operator==()

G4bool G4VSolid::operator== ( const G4VSolid & s ) const

inlineinherited

◆ OutsideOfExtent()

G4bool G4TessellatedSolid::OutsideOfExtent	(	const G4ThreeVector &	p,
		G4double	tolerance = `0.0`
	)		const

inlineprivate

Definition at line 319 of file G4TessellatedSolid.hh.

{
  return ( p.x() < fMinExtent.x() - tolerance
        || p.x() > fMaxExtent.x() + tolerance
        || p.y() < fMinExtent.y() - tolerance
        || p.y() > fMaxExtent.y() + tolerance
        || p.z() < fMinExtent.z() - tolerance
        || p.z() > fMaxExtent.z() + tolerance);
}

References fMaxExtent, fMinExtent, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by AddFacet(), CreateVertexList(), InsideNoVoxels(), InsideVoxels(), SafetyFromInside(), and SafetyFromOutside().

◆ PrecalculateInsides()

void G4TessellatedSolid::PrecalculateInsides ( )

private

Definition at line 336 of file G4TessellatedSolid.cc.

{
  vector<G4int> voxel(3), maxVoxels(3);
  for (auto i = 0; i <= 2; ++i) maxVoxels[i] = fVoxels.GetBoundary(i).size();
  G4int size = maxVoxels[0] * maxVoxels[1] * maxVoxels[2];
 
  G4SurfBits checked(size-1);
  fInsides.Clear();
  fInsides.ResetBitNumber(size-1);
 
  G4ThreeVector point;
  for (voxel[2] = 0; voxel[2] < maxVoxels[2] - 1; ++voxel[2])
  {
    for (voxel[1] = 0; voxel[1] < maxVoxels[1] - 1; ++voxel[1])
    {
      for (voxel[0] = 0; voxel[0] < maxVoxels[0] - 1; ++voxel[0])
      {
        G4int index = fVoxels.GetVoxelsIndex(voxel);
        if (!checked[index] && fVoxels.IsEmpty(index))
        {
          for (auto i = 0; i <= 2; ++i)
          {
            point[i] = fVoxels.GetBoundary(i)[voxel[i]];
          }
          G4bool inside = (G4bool) (InsideNoVoxels(point) == kInside);
          SetAllUsingStack(voxel, maxVoxels, inside, checked);
        }
        else checked.SetBitNumber(index);
      }
    }
  }
}

References G4SurfBits::Clear(), fInsides, fVoxels, G4Voxelizer::GetBoundary(), G4Voxelizer::GetVoxelsIndex(), InsideNoVoxels(), G4Voxelizer::IsEmpty(), kInside, G4SurfBits::ResetBitNumber(), SetAllUsingStack(), and G4SurfBits::SetBitNumber().

Referenced by Voxelize().

◆ SafetyFromInside()

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

virtual

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

References G4VFacet::Distance(), DistanceToIn(), fFacets, fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCountOfVoxels(), Inside(), JustWarning, G4VSolid::kCarTolerance, kInfinity, kOutside, MinDistanceFacet(), mm, OutsideOfExtent(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToOut().

◆ SafetyFromOutside()

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

virtual

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

References G4VFacet::Distance(), G4Voxelizer::DistanceToBoundingBox(), DistanceToOut(), fFacets, fInsides, fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4SurfBits::GetNbits(), G4Voxelizer::GetPointIndex(), G4Voxelizer::GetVoxel(), Inside(), JustWarning, G4VSolid::kCarTolerance, kInfinity, kInside, MinDistanceFacet(), mm, OutsideOfExtent(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToIn().

◆ SetAllUsingStack()

G4int G4TessellatedSolid::SetAllUsingStack	(	const std::vector< G4int > &	voxel,
		const std::vector< G4int > &	max,
		G4bool	status,
		G4SurfBits &	checked
	)

private

Definition at line 280 of file G4TessellatedSolid.cc.

{
  vector<G4int> xyz = voxel;
  stack<vector<G4int> > pos;
  pos.push(xyz);
  G4int filled = 0;
  G4int cc = 0, nz = 0;
 
  vector<G4int> candidates;
 
  while (!pos.empty())    // Loop checking, 13.08.2015, G.Cosmo
  {
    xyz = pos.top();
    pos.pop();
    G4int index = fVoxels.GetVoxelsIndex(xyz);
    if (!checked[index])
    {
      checked.SetBitNumber(index, true);
      ++cc;
 
      if (fVoxels.IsEmpty(index))
      {
        ++filled;
 
        fInsides.SetBitNumber(index, status);
 
        for (auto i = 0; i <= 2; ++i)
        {
          if (xyz[i] < max[i] - 1)
          {
            xyz[i]++;
            pos.push(xyz);
            xyz[i]--;
          }
 
          if (xyz[i] > 0)
          {
            xyz[i]--;
            pos.push(xyz);
            xyz[i]++;
          }
        }
      }
      else
      {
        ++nz;
      }
    }
  }
  return filled;
}

References fInsides, fVoxels, G4Voxelizer::GetVoxelsIndex(), G4Voxelizer::IsEmpty(), G4INCL::Math::max(), pos, and G4SurfBits::SetBitNumber().

Referenced by PrecalculateInsides().

◆ SetExtremeFacets()

void G4TessellatedSolid::SetExtremeFacets ( )

private

Definition at line 399 of file G4TessellatedSolid.cc.

{
  // Copy vertices to local array
  G4int vsize = fVertexList.size();
  std::vector<G4ThreeVector> vertices(vsize);
  for (G4int i = 0; i < vsize; ++i) { vertices[i] = fVertexList[i]; }
 
  // Shuffle vertices
  std::mt19937 gen(12345678);
  std::shuffle(vertices.begin(), vertices.end(), gen);
 
  // Select six extreme vertices in different directions
  G4ThreeVector points[6];
  for (G4int i=0; i < 6; ++i) { points[i] = vertices[0]; }
  for (G4int i=1; i < vsize; ++i)
  {
    if (vertices[i].x() < points[0].x()) points[0] = vertices[i];
    if (vertices[i].x() > points[1].x()) points[1] = vertices[i];
    if (vertices[i].y() < points[2].y()) points[2] = vertices[i];
    if (vertices[i].y() > points[3].y()) points[3] = vertices[i];
    if (vertices[i].z() < points[4].z()) points[4] = vertices[i];
    if (vertices[i].z() > points[5].z()) points[5] = vertices[i];
  }
 
  // Find extreme facets
  G4int size = fFacets.size();
  for (G4int j = 0; j < size; ++j)
  {
    G4VFacet &facet = *fFacets[j];
 
    // Check extreme vertices
    if (!facet.IsInside(points[0])) continue;
    if (!facet.IsInside(points[1])) continue;
    if (!facet.IsInside(points[2])) continue;
    if (!facet.IsInside(points[3])) continue;
    if (!facet.IsInside(points[4])) continue;
    if (!facet.IsInside(points[5])) continue;
 
    // Check vertices
    G4bool isExtreme = true;
    for (G4int i=0; i < vsize; ++i)
    {
      if (!facet.IsInside(vertices[i]))
      {
        isExtreme = false;
        break;
      }
    }
    if (isExtreme) fExtremeFacets.insert(&facet);
  }
}

References fExtremeFacets, fFacets, fVertexList, and G4VFacet::IsInside().

Referenced by SetSolidClosed().

◆ SetMaxVoxels()

void G4TessellatedSolid::SetMaxVoxels ( G4int max )

inline

Definition at line 309 of file G4TessellatedSolid.hh.

{
  fVoxels.SetMaxVoxels(max);
}

References fVoxels, G4INCL::Math::max(), and G4Voxelizer::SetMaxVoxels().

◆ SetName()

void G4VSolid::SetName ( const G4String & name )

inherited

Definition at line 127 of file G4VSolid.cc.

{
  fshapeName = name;
  G4SolidStore::GetInstance()->SetMapValid(false);
}

References G4VSolid::fshapeName, G4SolidStore::GetInstance(), G4InuclParticleNames::name(), and G4SolidStore::SetMapValid().

Referenced by export_G4VSolid(), G4MultiUnion::G4MultiUnion(), and G4GDMLRead::StripNames().

◆ SetRandomVectors()

void G4TessellatedSolid::SetRandomVectors ( )

private

Definition at line 2176 of file G4TessellatedSolid.cc.

{
  fRandir.resize(20);
  fRandir[0]  =
    G4ThreeVector(-0.9577428892113370, 0.2732676269591740, 0.0897405271949221);
  fRandir[1]  =
    G4ThreeVector(-0.8331264504940770,-0.5162067214954600,-0.1985722492445700);
  fRandir[2]  =
    G4ThreeVector(-0.1516671651108820, 0.9666292616127460, 0.2064580868390110);
  fRandir[3]  =
    G4ThreeVector( 0.6570250350323190,-0.6944539025883300, 0.2933460081893360);
  fRandir[4]  =
    G4ThreeVector(-0.4820456281280320,-0.6331060000098690,-0.6056474264406270);
  fRandir[5]  =
    G4ThreeVector( 0.7629032554236800 , 0.1016854697539910,-0.6384658864065180);
  fRandir[6]  =
    G4ThreeVector( 0.7689540409061150, 0.5034929891988220, 0.3939600142169160);
  fRandir[7]  =
    G4ThreeVector( 0.5765188359255740, 0.5997271636278330,-0.5549354566343150);
  fRandir[8]  =
    G4ThreeVector( 0.6660632777862070,-0.6362809868288380, 0.3892379937580790);
  fRandir[9]  =
    G4ThreeVector( 0.3824415020414780, 0.6541792713761380,-0.6525243125110690);
  fRandir[10] =
    G4ThreeVector(-0.5107726564526760, 0.6020905056811610, 0.6136760679616570);
  fRandir[11] =
    G4ThreeVector( 0.7459135439578050, 0.6618796061649330, 0.0743530220183488);
  fRandir[12] =
    G4ThreeVector( 0.1536405855311580, 0.8117477913978260,-0.5634359711967240);
  fRandir[13] =
    G4ThreeVector( 0.0744395301705579,-0.8707110101772920,-0.4861286795736560);
  fRandir[14] =
    G4ThreeVector(-0.1665874645185400, 0.6018553940549240,-0.7810369397872780);
  fRandir[15] =
    G4ThreeVector( 0.7766902003633100, 0.6014617505959970,-0.1870724331097450);
  fRandir[16] =
    G4ThreeVector(-0.8710128685847430,-0.1434320216603030,-0.4698551243971010);
  fRandir[17] =
    G4ThreeVector( 0.8901082092766820,-0.4388411398893870, 0.1229871120030100);
  fRandir[18] =
    G4ThreeVector(-0.6430417431544370,-0.3295938228697690, 0.6912779675984150);
  fRandir[19] =
    G4ThreeVector( 0.6331124368380410, 0.6306211461665000, 0.4488714875425340);
 
  fMaxTries = 20;
}

References fMaxTries, and fRandir.

Referenced by Initialize().

◆ SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed ( const G4bool t )

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

References CheckStructure(), CreateVertexList(), DisplayAllocatedMemory(), fSolidClosed, G4cout, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, SetExtremeFacets(), and Voxelize().

Referenced by CopyObjects(), G4GenericTrap::CreateTessellatedSolid(), G4ExtrudedSolid::MakeFacets(), and G4GDMLReadSolids::TessellatedRead().

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

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

References fFacets, fGeometryType, G4endl, G4VSolid::GetName(), and G4VFacet::StreamInfo().

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1815 of file G4TessellatedSolid.cc.

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

References CLHEP::detail::n, and Normal().

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

◆ Voxelize()

void G4TessellatedSolid::Voxelize ( )

private

Definition at line 371 of file G4TessellatedSolid.cc.

{
#ifdef G4SPECSDEBUG
  G4cout << "Voxelizing..." << G4endl;
#endif
  fVoxels.Voxelize(fFacets);
 
  if (fVoxels.Empty().GetNbits())
  {
#ifdef G4SPECSDEBUG
    G4cout << "Precalculating Insides..." << G4endl;
#endif
    PrecalculateInsides();
  }
}

References G4Voxelizer::Empty(), fFacets, fVoxels, G4cout, G4endl, G4SurfBits::GetNbits(), PrecalculateInsides(), and G4Voxelizer::Voxelize().

Referenced by SetSolidClosed().

Field Documentation

◆ fCubicVolume

G4double G4TessellatedSolid::fCubicVolume = 0.0

private

Definition at line 280 of file G4TessellatedSolid.hh.

Referenced by GetCubicVolume(), and Initialize().

◆ fExtremeFacets

std::set<G4VFacet*> G4TessellatedSolid::fExtremeFacets

private

Definition at line 276 of file G4TessellatedSolid.hh.

Referenced by AllocatedMemoryWithoutVoxels(), DistanceToOutCore(), DistanceToOutNoVoxels(), and SetExtremeFacets().

◆ fFacetList

std::set<G4VertexInfo,G4VertexComparator> G4TessellatedSolid::fFacetList

private

Definition at line 285 of file G4TessellatedSolid.hh.

Referenced by AddFacet().

◆ fFacets

std::vector<G4VFacet*> G4TessellatedSolid::fFacets

private

◆ fGeometryType

G4GeometryType G4TessellatedSolid::fGeometryType

private

Definition at line 279 of file G4TessellatedSolid.hh.

Referenced by GetEntityType(), Initialize(), InsideNoVoxels(), InsideVoxels(), and StreamInfo().

◆ fInsides

G4SurfBits G4TessellatedSolid::fInsides

private

Definition at line 297 of file G4TessellatedSolid.hh.

Referenced by AllocatedMemory(), InsideVoxels(), PrecalculateInsides(), SafetyFromOutside(), and SetAllUsingStack().

◆ fMaxExtent

G4ThreeVector G4TessellatedSolid::fMaxExtent

private

Definition at line 287 of file G4TessellatedSolid.hh.

Referenced by BoundingLimits(), CreateVertexList(), G4TessellatedSolid(), GetExtent(), GetMaxXExtent(), GetMaxYExtent(), GetMaxZExtent(), Initialize(), and OutsideOfExtent().

◆ fMaxTries

G4int G4TessellatedSolid::fMaxTries

private

Definition at line 293 of file G4TessellatedSolid.hh.

Referenced by InsideNoVoxels(), InsideVoxels(), and SetRandomVectors().

◆ fMinExtent

G4ThreeVector G4TessellatedSolid::fMinExtent

private

Definition at line 287 of file G4TessellatedSolid.hh.

Referenced by BoundingLimits(), CreateVertexList(), G4TessellatedSolid(), GetExtent(), GetMinXExtent(), GetMinYExtent(), GetMinZExtent(), Initialize(), and OutsideOfExtent().

◆ fpPolyhedron

G4Polyhedron* G4TessellatedSolid::fpPolyhedron = nullptr

mutableprivate

Definition at line 273 of file G4TessellatedSolid.hh.

Referenced by DeleteObjects(), GetPolyhedron(), and Initialize().

◆ fRandir

std::vector<G4ThreeVector> G4TessellatedSolid::fRandir

private

Definition at line 291 of file G4TessellatedSolid.hh.

Referenced by AllocatedMemoryWithoutVoxels(), InsideNoVoxels(), InsideVoxels(), and SetRandomVectors().

◆ fRebuildPolyhedron

G4bool G4TessellatedSolid::fRebuildPolyhedron = false

mutableprivate

Definition at line 272 of file G4TessellatedSolid.hh.

Referenced by GetPolyhedron(), and Initialize().

◆ fshapeName

G4String G4VSolid::fshapeName

privateinherited

Definition at line 312 of file G4VSolid.hh.

Referenced by G4VSolid::operator=(), and G4VSolid::SetName().

◆ fSolidClosed

G4bool G4TessellatedSolid::fSolidClosed = false

private

Definition at line 289 of file G4TessellatedSolid.hh.

Referenced by AddFacet(), GetSolidClosed(), Initialize(), and SetSolidClosed().

◆ fSurfaceArea

G4double G4TessellatedSolid::fSurfaceArea = 0.0

private

Definition at line 281 of file G4TessellatedSolid.hh.

Referenced by GetSurfaceArea(), and Initialize().

◆ fVertexList

std::vector<G4ThreeVector> G4TessellatedSolid::fVertexList

private

Definition at line 283 of file G4TessellatedSolid.hh.

Referenced by AllocatedMemoryWithoutVoxels(), CreatePolyhedron(), CreateVertexList(), and SetExtremeFacets().

◆ fVoxels

G4Voxelizer G4TessellatedSolid::fVoxels

private

Definition at line 295 of file G4TessellatedSolid.hh.

Referenced by AllocatedMemory(), CopyObjects(), DistanceToInCore(), DistanceToOutCore(), GetFacetIndex(), GetVoxels(), Inside(), InsideVoxels(), MinDistanceFacet(), Normal(), PrecalculateInsides(), SafetyFromInside(), SafetyFromOutside(), SetAllUsingStack(), SetMaxVoxels(), and Voxelize().

◆ kCarTolerance

G4double G4VSolid::kCarTolerance

protectedinherited

Definition at line 299 of file G4VSolid.hh.

◆ kCarToleranceHalf

G4double G4TessellatedSolid::kCarToleranceHalf

protected

Definition at line 268 of file G4TessellatedSolid.hh.

Referenced by CalculateExtent(), G4ExtrudedSolid::DistanceToIn(), DistanceToInCandidates(), DistanceToInNoVoxels(), G4ExtrudedSolid::DistanceToOut(), DistanceToOutCandidates(), DistanceToOutNoVoxels(), G4ExtrudedSolid::G4ExtrudedSolid(), GetFacetIndex(), Initialize(), G4ExtrudedSolid::Inside(), InsideNoVoxels(), InsideVoxels(), G4ExtrudedSolid::IsSameLine(), G4ExtrudedSolid::IsSameLineSegment(), Normal(), and G4ExtrudedSolid::SurfaceNormal().

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

source/geometry/solids/specific/include/G4TessellatedSolid.hh
source/geometry/solids/specific/src/G4TessellatedSolid.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4TessellatedSolid() [1/4]

◆ ~G4TessellatedSolid()

◆ G4TessellatedSolid() [2/4]

◆ G4TessellatedSolid() [3/4]

◆ G4TessellatedSolid() [4/4]

Member Function Documentation

◆ AddFacet()

◆ AllocatedMemory()

◆ AllocatedMemoryWithoutVoxels()

◆ BoundingLimits()

◆ CalculateClippedPolygonExtent()

◆ CalculateExtent()

◆ CheckStructure()

◆ ClipBetweenSections()

◆ ClipCrossSection()

◆ ClipPolygon()

◆ ClipPolygonToSimpleLimits()

◆ Clone()

◆ CompareSortedVoxel()

◆ ComputeDimensions()

◆ CopyObjects()

◆ CreatePolyhedron()

◆ CreateVertexList()

◆ DeleteObjects()

◆ DescribeYourselfTo()

◆ DisplayAllocatedMemory()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToInCandidates()

◆ DistanceToInCore()

◆ DistanceToInNoVoxels()

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ DistanceToOutCandidates()

◆ DistanceToOutCore()

◆ DistanceToOutNoVoxels()

◆ DumpInfo()

◆ EstimateCubicVolume()

◆ EstimateSurfaceArea()

◆ GetConstituentSolid() [1/2]

◆ GetConstituentSolid() [2/2]

◆ GetCubicVolume()

◆ GetDisplacedSolidPtr() [1/2]

◆ GetDisplacedSolidPtr() [2/2]

◆ GetEntityType()

◆ GetExtent()

◆ GetFacet()

◆ GetFacetIndex()

◆ GetMaxXExtent()

◆ GetMaxYExtent()

◆ GetMaxZExtent()

◆ GetMinXExtent()

◆ GetMinYExtent()

◆ GetMinZExtent()

◆ GetName()

◆ GetNumberOfFacets()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSolidClosed()

◆ GetSurfaceArea()

◆ GetTolerance()

◆ GetVoxels()

◆ Initialize()

◆ Inside()

◆ InsideNoVoxels()

◆ InsideVoxels()

◆ MinDistanceFacet()

◆ Normal()

◆ operator+=()

◆ operator=()

◆ operator==()

◆ OutsideOfExtent()