#include <G4TessellatedSolid.hh>

Inheritance diagram for G4TessellatedSolid:

Collaboration diagram for G4TessellatedSolid:

Public Member Functions
	G4TessellatedSolid ()

virtual	~G4TessellatedSolid ()

	G4TessellatedSolid (const G4String &name)

	G4TessellatedSolid (__void__ &)

	G4TessellatedSolid (const G4TessellatedSolid &ts)

G4TessellatedSolid &	operator= (const G4TessellatedSolid &right)

G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)

G4bool	AddFacet (G4VFacet *aFacet)

G4VFacet *	GetFacet (G4int i) const

G4int	GetNumberOfFacets () const

virtual EInside	Inside (const G4ThreeVector &p) const

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const

virtual G4double	DistanceToIn (const G4ThreeVector &p) const

virtual G4double	DistanceToOut (const G4ThreeVector &p) const

virtual G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm, G4bool validNorm, G4ThreeVector norm) const

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

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

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

virtual G4GeometryType	GetEntityType () const

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

virtual G4VSolid *	Clone () const

virtual G4ThreeVector	GetPointOnSurface () const

virtual G4double	GetSurfaceArea ()

virtual G4double	GetCubicVolume ()

void	SetSolidClosed (const G4bool t)

G4bool	GetSolidClosed () const

void	SetMaxVoxels (G4int max)

G4SurfaceVoxelizer &	GetVoxels ()

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

G4double	GetMinXExtent () const

G4double	GetMaxXExtent () const

G4double	GetMinYExtent () const

G4double	GetMaxYExtent () const

G4double	GetMinZExtent () const

G4double	GetMaxZExtent () const

G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pT) const

virtual G4Polyhedron *	CreatePolyhedron () const

virtual G4Polyhedron *	GetPolyhedron () const

virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const

virtual G4VisExtent	GetExtent () const

G4int	AllocatedMemoryWithoutVoxels ()

G4int	AllocatedMemory ()

void	DisplayAllocatedMemory ()

Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

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

void	DumpInfo () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Attributes
G4double	kCarToleranceHalf

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Private Member Functions
void	Initialize ()

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

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

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

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

void	SetExtremeFacets ()

EInside	InsideNoVoxels (const G4ThreeVector &p) const

EInside	InsideVoxels (const G4ThreeVector &aPoint) const

void	Voxelize ()

void	CreateVertexList ()

void	PrecalculateInsides ()

void	SetRandomVectors ()

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

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

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

void	DeleteObjects ()

void	CopyObjects (const G4TessellatedSolid &s)

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

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

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

Private Attributes
G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

std::vector< G4VFacet * >	fFacets

std::set< G4VFacet * >	fExtremeFacets

G4GeometryType	fGeometryType

G4double	fCubicVolume

G4double	fSurfaceArea

std::vector< G4ThreeVector >	fVertexList

std::set< G4VertexInfo, G4VertexComparator >	fFacetList

G4ThreeVector	fMinExtent

G4ThreeVector	fMaxExtent

G4bool	fSolidClosed

std::vector< G4ThreeVector >	fRandir

G4int	fMaxTries

G4SurfaceVoxelizer	fVoxels

G4SurfBits	fInsides

Additional Inherited Members
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

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

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

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

Detailed Description

Definition at line 128 of file G4TessellatedSolid.hh.

Constructor & Destructor Documentation

◆ G4TessellatedSolid() [1/4]

G4TessellatedSolid::G4TessellatedSolid ( )

Definition at line 108 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~G4TessellatedSolid()

G4TessellatedSolid::~G4TessellatedSolid ( )

virtual

Definition at line 138 of file G4TessellatedSolid.cc.

 {
   DeleteObjects ();
 }

Here is the call graph for this function:

◆ G4TessellatedSolid() [2/4]

G4TessellatedSolid::G4TessellatedSolid ( const G4String & name )

Definition at line 118 of file G4TessellatedSolid.cc.

   : G4VSolid(name)
 {
   Initialize();
 }

Here is the call graph for this function:

◆ G4TessellatedSolid() [3/4]

G4TessellatedSolid::G4TessellatedSolid ( __void__ & a )

Definition at line 129 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

◆ G4TessellatedSolid() [4/4]

G4TessellatedSolid::G4TessellatedSolid ( const G4TessellatedSolid & ts )

Definition at line 147 of file G4TessellatedSolid.cc.

   : G4VSolid(ts), fpPolyhedron(0)
 {
   Initialize();
 
   CopyObjects(ts);
 }

Here is the call graph for this function:

Member Function Documentation

◆ AddFacet()

G4bool G4TessellatedSolid::AddFacet ( G4VFacet * aFacet )

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocatedMemory()

G4int G4TessellatedSolid::AllocatedMemory ( )

Definition at line 2086 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AllocatedMemoryWithoutVoxels()

G4int G4TessellatedSolid::AllocatedMemoryWithoutVoxels ( )

Definition at line 2060 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();
   }
 
   std::set<G4VFacet *>::const_iterator beg, end, it;
   beg = fExtremeFacets.begin();
   end = fExtremeFacets.end();
   for (it = beg; it != end; it++)
   {
     G4VFacet &facet = *(*it);
     base += facet.AllocatedMemory();
   }
   return base;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 1824 of file G4TessellatedSolid.cc.

 {
   G4ThreeVectorList transVertexList(fVertexList);
   G4int size = fVertexList.size();
 
   // Put solid into transformed frame
   for (G4int i=0; i < size; ++i)
   {
     pTransform.ApplyPointTransform(transVertexList[i]);
   }
 
   // Find min and max extent in each dimension
   G4ThreeVector minExtent(kInfinity, kInfinity, kInfinity);
   G4ThreeVector maxExtent(-kInfinity, -kInfinity, -kInfinity);
 
   size = transVertexList.size();
   for (G4int i=0; i< size; ++i)
   {
     for (G4int axis=G4ThreeVector::X; axis < G4ThreeVector::SIZE; ++axis)
     {
       G4double coordinate = transVertexList[i][axis];
       if (coordinate < minExtent[axis])
       { minExtent[axis] = coordinate; }
       if (coordinate > maxExtent[axis])
       { maxExtent[axis] = coordinate; }
     }
   }
 
   // Check for containment and clamp to voxel boundaries
   for (G4int axis=G4ThreeVector::X; axis < G4ThreeVector::SIZE; ++axis)
   {
     EAxis geomAxis = kXAxis; // U geom classes use different index type
     switch(axis)
     {
     case G4ThreeVector::X: geomAxis = kXAxis; break;
     case G4ThreeVector::Y: geomAxis = kYAxis; break;
     case G4ThreeVector::Z: geomAxis = kZAxis; break;
     }
     G4bool isLimited = pVoxelLimit.IsLimited(geomAxis);
     G4double voxelMinExtent = pVoxelLimit.GetMinExtent(geomAxis);
     G4double voxelMaxExtent = pVoxelLimit.GetMaxExtent(geomAxis);
 
     if (isLimited)
     {
       if ( minExtent[axis] > voxelMaxExtent+kCarTolerance ||
         maxExtent[axis] < voxelMinExtent-kCarTolerance    )
       {
         return false ;
       }
       else
       {
         if (minExtent[axis] < voxelMinExtent)
         {
           minExtent[axis] = voxelMinExtent ;
         }
         if (maxExtent[axis] > voxelMaxExtent)
         {
           maxExtent[axis] = voxelMaxExtent;
         }
       }
     }
   }
 
   // Convert pAxis into G4ThreeVector index
   G4int vecAxis=0;
   switch(pAxis)
   {
   case kXAxis: vecAxis = G4ThreeVector::X; break;
   case kYAxis: vecAxis = G4ThreeVector::Y; break;
   case kZAxis: vecAxis = G4ThreeVector::Z; break;
   default: break;
   } 
 
   pMin = minExtent[vecAxis] - kCarTolerance;
   pMax = maxExtent[vecAxis] + kCarTolerance;
 
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clone()

G4VSolid * G4TessellatedSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1620 of file G4TessellatedSolid.cc.

 {
   return new G4TessellatedSolid(*this);
 }

Here is the call graph for this function:

◆ CompareSortedVoxel()

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

staticprivate

Definition at line 1423 of file G4TessellatedSolid.cc.

 {
   return l.second < r.second;
 }

Here is the caller graph for this function:

◆ CopyObjects()

void G4TessellatedSolid::CopyObjects ( const G4TessellatedSolid & s )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1765 of file G4TessellatedSolid.cc.

 {
   G4int nVertices = fVertexList.size();
   G4int nFacets   = fFacets.size();
   G4PolyhedronArbitrary *polyhedron =
     new G4PolyhedronArbitrary (nVertices, nFacets);
   for (G4ThreeVectorList::const_iterator v= fVertexList.begin();
                                          v!=fVertexList.end(); ++v)
   {
     polyhedron->AddVertex(*v);
   }
 
   G4int size = fFacets.size();
   for (G4int i = 0; i < size; ++i)
   {
     G4VFacet &facet = *fFacets[i];
     G4int v[4];
     G4int n = facet.GetNumberOfVertices();
     if (n > 4) n = 4;
     else if (n == 3) v[3] = 0;
     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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateRotatedVertices()

G4ThreeVectorList* G4TessellatedSolid::CreateRotatedVertices ( const G4AffineTransform & pT ) const

◆ CreateVertexList()

void G4TessellatedSolid::CreateVertexList ( )

private

Definition at line 441 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 (set<G4VertexInfo,G4VertexComparator>::iterator res=
        vertexListSorted.begin(); res!=vertexListSorted.end(); ++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
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeleteObjects()

void G4TessellatedSolid::DeleteObjects ( )

private

Definition at line 196 of file G4TessellatedSolid.cc.

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

Here is the caller graph for this function:

◆ DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1758 of file G4TessellatedSolid.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory ( )

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 1666 of file G4TessellatedSolid.cc.

 {
   return SafetyFromOutside(p,false);
 }

Here is the call graph for this function:

◆ DistanceToInCandidates()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToInCore()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToInNoVoxels()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1701 of file G4TessellatedSolid.cc.

 {
   return SafetyFromInside(p,false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 1724 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;
 }

Here is the call graph for this function:

◆ 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 1208 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;
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToOutCore()

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

private

Definition at line 1248 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 = 0;
 
     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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DistanceToOutNoVoxels()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCubicVolume()

G4double G4TessellatedSolid::GetCubicVolume ( )

virtual

Reimplemented from G4VSolid.

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

Here is the call graph for this function:

◆ GetEntityType()

G4GeometryType G4TessellatedSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1591 of file G4TessellatedSolid.cc.

 {
   return fGeometryType;
 }

◆ GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1950 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFacet()

G4VFacet * G4TessellatedSolid::GetFacet ( G4int i ) const

inline

Definition at line 305 of file G4TessellatedSolid.hh.

 {
   return fFacets[i];
 }

Here is the caller graph for this function:

◆ GetMaxXExtent()

G4double G4TessellatedSolid::GetMaxXExtent ( ) const

Definition at line 1915 of file G4TessellatedSolid.cc.

 {
   return fMaxExtent.x();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent ( ) const

Definition at line 1929 of file G4TessellatedSolid.cc.

 {
   return fMaxExtent.y();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent ( ) const

Definition at line 1943 of file G4TessellatedSolid.cc.

 {
   return fMaxExtent.z();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent ( ) const

Definition at line 1908 of file G4TessellatedSolid.cc.

 {
   return fMinExtent.x();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent ( ) const

Definition at line 1922 of file G4TessellatedSolid.cc.

 {
   return fMinExtent.y();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent ( ) const

Definition at line 1936 of file G4TessellatedSolid.cc.

 {
   return fMinExtent.z();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets ( ) const

Definition at line 648 of file G4TessellatedSolid.cc.

 {
   return fFacets.size();
 }

Here is the caller graph for this function:

◆ GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPolyhedron()

G4Polyhedron * G4TessellatedSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1801 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSolidClosed()

G4bool G4TessellatedSolid::GetSolidClosed ( ) const

Definition at line 620 of file G4TessellatedSolid.cc.

 {
   return fSolidClosed;
 }

Here is the caller graph for this function:

◆ GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

virtual

Reimplemented from G4VSolid.

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

Here is the call graph for this function:

◆ GetVoxels()

G4SurfaceVoxelizer & G4TessellatedSolid::GetVoxels ( )

inline

Definition at line 315 of file G4TessellatedSolid.hh.

 {
   return fVoxels;
 }

◆ Initialize()

void G4TessellatedSolid::Initialize ( )

private

Definition at line 178 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Inside()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1635 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsideNoVoxels()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InsideVoxels()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MinDistanceFacet()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Normal()

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

virtual

Definition at line 992 of file G4TessellatedSolid.cc.

 {
   G4double minDist;
   G4VFacet *facet = 0;
 
   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;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator+=()

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

Definition at line 635 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

◆ operator=()

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

Definition at line 160 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OutsideOfExtent()

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

inlineprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrecalculateInsides()

void G4TessellatedSolid::PrecalculateInsides ( )

private

Definition at line 358 of file G4TessellatedSolid.cc.

 {
   vector<G4int> voxel(3), maxVoxels(3);
   for (G4int 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 (G4int 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);
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SafetyFromInside()

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

virtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SafetyFromOutside()

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

virtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetAllUsingStack()

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

private

Definition at line 302 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 (G4int 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetExtremeFacets()

void G4TessellatedSolid::SetExtremeFacets ( )

private

Definition at line 418 of file G4TessellatedSolid.cc.

 {
   G4int size = fFacets.size();
   for (G4int j = 0; j < size; ++j)
   {
     G4VFacet &facet = *fFacets[j];
 
     G4bool isExtreme = true;
     G4int vsize = fVertexList.size();
     for (G4int i=0; i < vsize; ++i)
     {
       if (!facet.IsInside(fVertexList[i]))
       {
         isExtreme = false;
         break;
       }
     }
     if (isExtreme) fExtremeFacets.insert(&facet);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMaxVoxels()

void G4TessellatedSolid::SetMaxVoxels ( G4int max )

inline

Definition at line 310 of file G4TessellatedSolid.hh.

 {
   fVoxels.SetMaxVoxels(max);
 }

◆ SetRandomVectors()

void G4TessellatedSolid::SetRandomVectors ( )

private

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

Here is the caller graph for this function:

◆ SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed ( const G4bool t )

Definition at line 587 of file G4TessellatedSolid.cc.

 {
   if (t)
   {
 #ifdef G4SPECSDEBUG    
     G4cout << "Creating vertex list..." << G4endl;
 #endif
     CreateVertexList();
 
 #ifdef G4SPECSDEBUG    
     G4cout << "Setting extreme facets..." << G4endl;
 #endif
     SetExtremeFacets();
     
 #ifdef G4SPECSDEBUG    
     G4cout << "Voxelizing..." << G4endl;
 #endif
     Voxelize();
 
 #ifdef G4SPECSDEBUG
     DisplayAllocatedMemory();
 #endif
 
   }  
   fSolidClosed = t;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Reimplemented in G4ExtrudedSolid.

Definition at line 1598 of file G4TessellatedSolid.cc.

 {
   os << 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;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 1652 of file G4TessellatedSolid.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Voxelize()

void G4TessellatedSolid::Voxelize ( )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fCubicVolume

G4double G4TessellatedSolid::fCubicVolume

private

Definition at line 281 of file G4TessellatedSolid.hh.

◆ fExtremeFacets

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

private

Definition at line 277 of file G4TessellatedSolid.hh.

◆ fFacetList

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

private

Definition at line 286 of file G4TessellatedSolid.hh.

◆ fFacets

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

private

Definition at line 276 of file G4TessellatedSolid.hh.

◆ fGeometryType

G4GeometryType G4TessellatedSolid::fGeometryType

private

Definition at line 280 of file G4TessellatedSolid.hh.

◆ fInsides

G4SurfBits G4TessellatedSolid::fInsides

private

Definition at line 298 of file G4TessellatedSolid.hh.

◆ fMaxExtent

G4ThreeVector G4TessellatedSolid::fMaxExtent

private

Definition at line 288 of file G4TessellatedSolid.hh.

◆ fMaxTries

G4int G4TessellatedSolid::fMaxTries

private

Definition at line 294 of file G4TessellatedSolid.hh.

◆ fMinExtent

G4ThreeVector G4TessellatedSolid::fMinExtent

private

Definition at line 288 of file G4TessellatedSolid.hh.

◆ fpPolyhedron

G4Polyhedron* G4TessellatedSolid::fpPolyhedron

mutableprivate

Definition at line 274 of file G4TessellatedSolid.hh.

◆ fRandir

std::vector<G4ThreeVector> G4TessellatedSolid::fRandir

private

Definition at line 292 of file G4TessellatedSolid.hh.

◆ fRebuildPolyhedron

G4bool G4TessellatedSolid::fRebuildPolyhedron

mutableprivate

Definition at line 273 of file G4TessellatedSolid.hh.

◆ fSolidClosed

G4bool G4TessellatedSolid::fSolidClosed

private

Definition at line 290 of file G4TessellatedSolid.hh.

◆ fSurfaceArea

G4double G4TessellatedSolid::fSurfaceArea

private

Definition at line 282 of file G4TessellatedSolid.hh.

◆ fVertexList

std::vector<G4ThreeVector> G4TessellatedSolid::fVertexList

private

Definition at line 284 of file G4TessellatedSolid.hh.

◆ fVoxels

G4SurfaceVoxelizer G4TessellatedSolid::fVoxels

private

Definition at line 296 of file G4TessellatedSolid.hh.

◆ kCarToleranceHalf

G4double G4TessellatedSolid::kCarToleranceHalf

protected

Definition at line 269 of file G4TessellatedSolid.hh.

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

Public Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4TessellatedSolid() [1/4]

◆ ~G4TessellatedSolid()

◆ G4TessellatedSolid() [2/4]

◆ G4TessellatedSolid() [3/4]

◆ G4TessellatedSolid() [4/4]

Member Function Documentation

◆ AddFacet()

◆ AllocatedMemory()

◆ AllocatedMemoryWithoutVoxels()

◆ CalculateExtent()

◆ Clone()

◆ CompareSortedVoxel()

◆ CopyObjects()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ CreateVertexList()

◆ DeleteObjects()

◆ DescribeYourselfTo()

◆ DisplayAllocatedMemory()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToInCandidates()

◆ DistanceToInCore()

◆ DistanceToInNoVoxels()

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ DistanceToOutCandidates()

◆ DistanceToOutCore()

◆ DistanceToOutNoVoxels()

◆ GetCubicVolume()

◆ GetEntityType()

◆ GetExtent()

◆ GetFacet()

◆ GetMaxXExtent()

◆ GetMaxYExtent()

◆ GetMaxZExtent()

◆ GetMinXExtent()

◆ GetMinYExtent()

◆ GetMinZExtent()

◆ GetNumberOfFacets()

◆ GetPointOnSurface()

◆ GetPolyhedron()

◆ GetSolidClosed()

◆ GetSurfaceArea()

◆ GetVoxels()

◆ Initialize()

◆ Inside()

◆ InsideNoVoxels()

◆ InsideVoxels()

◆ MinDistanceFacet()

◆ Normal()

◆ operator+=()

◆ operator=()

◆ OutsideOfExtent()

◆ PrecalculateInsides()

◆ SafetyFromInside()

◆ SafetyFromOutside()

◆ SetAllUsingStack()

◆ SetExtremeFacets()

◆ SetMaxVoxels()

◆ SetRandomVectors()

◆ SetSolidClosed()

◆ StreamInfo()

◆ SurfaceNormal()

◆ Voxelize()

Member Data Documentation

◆ fCubicVolume

◆ fExtremeFacets

◆ fFacetList

◆ fFacets

◆ fGeometryType

◆ fInsides