#include <G4ExtrudedSolid.hh>

Inheritance diagram for G4ExtrudedSolid:

Data Structures
struct	line

struct	plane

struct	ZSection

Public Member Functions
G4bool	AddFacet (G4VFacet *aFacet)

G4int	AllocatedMemory ()

G4int	AllocatedMemoryWithoutVoxels ()

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

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

G4int	CheckStructure () const

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 ()

G4double	DistanceToIn (const G4ThreeVector &p) const

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

G4double	DistanceToOut (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=nullptr, G4ThreeVector n=nullptr) const

void	DumpInfo () const

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

	G4ExtrudedSolid (__void__ &)

	G4ExtrudedSolid (const G4ExtrudedSolid &rhs)

	G4ExtrudedSolid (const G4String &pName, const std::vector< G4TwoVector > &polygon, const std::vector< ZSection > &zsections)

	G4ExtrudedSolid (const G4String &pName, const std::vector< G4TwoVector > &polygon, G4double halfZ, const G4TwoVector &off1, G4double scale1, const G4TwoVector &off2, G4double scale2)

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4double	GetCubicVolume ()

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

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	GetNofVertices () const

G4int	GetNofZSections () const

G4int	GetNumberOfFacets () const

virtual G4ThreeVector	GetPointOnSurface () const

std::vector< G4TwoVector >	GetPolygon () const

virtual G4Polyhedron *	GetPolyhedron () const

G4bool	GetSolidClosed () const

virtual G4double	GetSurfaceArea ()

G4double	GetTolerance () const

G4TwoVector	GetVertex (G4int index) const

G4Voxelizer &	GetVoxels ()

ZSection	GetZSection (G4int index) const

std::vector< ZSection >	GetZSections () const

EInside	Inside (const G4ThreeVector &p) const

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

G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)

G4ExtrudedSolid &	operator= (const G4ExtrudedSolid &rhs)

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)

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

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

virtual	~G4ExtrudedSolid ()

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
G4bool	AddGeneralPolygonFacets ()

G4ThreeVector	ApproxSurfaceNormal (const G4ThreeVector &p) const

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

void	ComputeLateralPlanes ()

void	ComputeProjectionParameters ()

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

G4double	DistanceToPolygonSqr (const G4ThreeVector &p) const

G4double	GetAngle (const G4TwoVector &p0, const G4TwoVector &pa, const G4TwoVector &pb) const

G4ThreeVector	GetVertex (G4int iz, G4int ind) const

void	Initialize ()

EInside	InsideNoVoxels (const G4ThreeVector &p) const

EInside	InsideVoxels (const G4ThreeVector &aPoint) const

G4bool	IsPointInside (const G4TwoVector &a, const G4TwoVector &b, const G4TwoVector &c, const G4TwoVector &p) const

G4bool	IsSameLine (const G4TwoVector &p, const G4TwoVector &l1, const G4TwoVector &l2) const

G4bool	IsSameLineSegment (const G4TwoVector &p, const G4TwoVector &l1, const G4TwoVector &l2) const

G4bool	IsSameSide (const G4TwoVector &p1, const G4TwoVector &p2, const G4TwoVector &l1, const G4TwoVector &l2) const

G4VFacet *	MakeDownFacet (G4int ind1, G4int ind2, G4int ind3) const

G4bool	MakeFacets ()

G4VFacet *	MakeUpFacet (G4int ind1, G4int ind2, G4int ind3) const

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

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

G4bool	PointInPolygon (const G4ThreeVector &p) const

void	PrecalculateInsides ()

G4TwoVector	ProjectPoint (const G4ThreeVector &point) const

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

G4bool	fIsConvex = false

std::vector< G4TwoVector >	fKOffsets

std::vector< G4double >	fKScales

std::vector< G4double >	fLengths

std::vector< line >	fLines

G4ThreeVector	fMaxExtent

G4int	fMaxTries

G4ThreeVector	fMinExtent

G4int	fNv

G4int	fNz

std::vector< G4TwoVector >	fOffset0s

std::vector< plane >	fPlanes

std::vector< G4TwoVector >	fPolygon

G4Polyhedron *	fpPolyhedron = nullptr

std::vector< G4ThreeVector >	fRandir

G4bool	fRebuildPolyhedron = false

std::vector< G4double >	fScale0s

G4String	fshapeName

G4bool	fSolidClosed = false

G4int	fSolidType = 0

G4double	fSurfaceArea = 0.0

std::vector< std::vector< G4int > >	fTriangles

std::vector< G4ThreeVector >	fVertexList

G4Voxelizer	fVoxels

std::vector< ZSection >	fZSections

Detailed Description

Definition at line 71 of file G4ExtrudedSolid.hh.

Constructor & Destructor Documentation

◆ G4ExtrudedSolid() [1/4]

G4ExtrudedSolid::G4ExtrudedSolid	(	const G4String &	pName,
		const std::vector< G4TwoVector > &	polygon,
		const std::vector< ZSection > &	zsections
	)

Definition at line 66 of file G4ExtrudedSolid.cc.

  : G4TessellatedSolid(pName),
    fNv(polygon.size()),
    fNz(zsections.size()),
    fIsConvex(false),
    fGeometryType("G4ExtrudedSolid"),
    fSolidType(0)
{
  // General constructor
 
  // First check input parameters
 
  if (fNv < 3)
  {
    std::ostringstream message;
    message << "Number of vertices in polygon < 3 - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
     
  if (fNz < 2)
  {
    std::ostringstream message;
    message << "Number of z-sides < 2 - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
     
  for ( G4int i=0; i<fNz-1; ++i ) 
  {
    if ( zsections[i].fZ > zsections[i+1].fZ ) 
    {
      std::ostringstream message;
      message << "Z-sections have to be ordered by z value (z0 < z1 < z2...) - "
              << pName;
      G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
                  FatalErrorInArgument, message);
    }
    if ( std::fabs( zsections[i+1].fZ - zsections[i].fZ ) < kCarToleranceHalf )
    {
      std::ostringstream message;
      message << "Z-sections with the same z position are not supported - "
              << pName;
      G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0001",
                  FatalException, message);
    }
  }  
  
  // Copy polygon
  //
  fPolygon = polygon;
 
  // Remove collinear and coincident vertices, if any
  //
  std::vector<G4int> removedVertices;
  G4GeomTools::RemoveRedundantVertices(fPolygon,removedVertices,
                                       2*kCarTolerance);
  if (removedVertices.size() != 0)
  {
    G4int nremoved = removedVertices.size();
    std::ostringstream message;
    message << "The following "<< nremoved 
            << " vertices have been removed from polygon in " << pName 
            << "\nas collinear or coincident with other vertices: "
            << removedVertices[0];
    for (G4int i=1; i<nremoved; ++i) message << ", " << removedVertices[i];
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
                JustWarning, message);
  }
 
  fNv = fPolygon.size();
  if (fNv < 3)
  {
    std::ostringstream message;
    message << "Number of vertices in polygon after removal < 3 - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  // Check if polygon vertices are defined clockwise
  // (the area is positive if polygon vertices are defined anti-clockwise)
  //
  if (G4GeomTools::PolygonArea(fPolygon) > 0.)
  {   
    // Polygon vertices are defined anti-clockwise, we revert them
    // G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
    //            JustWarning, 
    //            "Polygon vertices defined anti-clockwise, reverting polygon");
    std::reverse(fPolygon.begin(),fPolygon.end());
  }
 
  // Copy z-sections
  //
  fZSections = zsections;
 
  G4bool result = MakeFacets();
  if (!result)
  {   
    std::ostringstream message;
    message << "Making facets failed - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0003",
                FatalException, message);
  }
  fIsConvex = G4GeomTools::IsConvex(fPolygon);
  
  ComputeProjectionParameters();
 
  // Check if the solid is a right prism, if so then set lateral planes
  //
  if ((fNz == 2)
      && (fZSections[0].fScale == 1) && (fZSections[1].fScale == 1)
      && (fZSections[0].fOffset == G4TwoVector(0,0))
      && (fZSections[1].fOffset == G4TwoVector(0,0)))
  {
    fSolidType = (fIsConvex) ? 1 : 2; // 1 - convex, 2 - non-convex right prism
    ComputeLateralPlanes();
  }
}

References ComputeLateralPlanes(), ComputeProjectionParameters(), FatalErrorInArgument, FatalException, fIsConvex, fNv, fNz, fPolygon, fSolidType, fZSections, G4Exception(), G4GeomTools::IsConvex(), JustWarning, G4VSolid::kCarTolerance, G4TessellatedSolid::kCarToleranceHalf, MakeFacets(), G4GeomTools::PolygonArea(), and G4GeomTools::RemoveRedundantVertices().

Referenced by Clone().

◆ G4ExtrudedSolid() [2/4]

G4ExtrudedSolid::G4ExtrudedSolid	(	const G4String &	pName,
		const std::vector< G4TwoVector > &	polygon,
		G4double	halfZ,
		const G4TwoVector &	off1,
		G4double	scale1,
		const G4TwoVector &	off2,
		G4double	scale2
	)

Definition at line 189 of file G4ExtrudedSolid.cc.

  : G4TessellatedSolid(pName),
    fNv(polygon.size()),
    fNz(2),
    fGeometryType("G4ExtrudedSolid")
{
  // Special constructor for solid with 2 z-sections
 
  // First check input parameters
  //
  if (fNv < 3)
  {
    std::ostringstream message;
    message << "Number of vertices in polygon < 3 - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
     
  // Copy polygon
  //
  fPolygon = polygon;
 
  // Remove collinear and coincident vertices, if any
  //
  std::vector<G4int> removedVertices;
  G4GeomTools::RemoveRedundantVertices(fPolygon,removedVertices,
                                       2*kCarTolerance);
  if (removedVertices.size() != 0)
  {
    G4int nremoved = removedVertices.size();
    std::ostringstream message;
    message << "The following "<< nremoved 
            << " vertices have been removed from polygon in " << pName 
            << "\nas collinear or coincident with other vertices: "
            << removedVertices[0];
    for (G4int i=1; i<nremoved; ++i) message << ", " << removedVertices[i];
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
                JustWarning, message);
  }
 
  fNv = fPolygon.size();
  if (fNv < 3)
  {
    std::ostringstream message;
    message << "Number of vertices in polygon after removal < 3 - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
                FatalErrorInArgument, message);
  }
 
  // Check if polygon vertices are defined clockwise
  // (the area is positive if polygon vertices are defined anti-clockwise)
  //  
  if (G4GeomTools::PolygonArea(fPolygon) > 0.)
  {
    // Polygon vertices are defined anti-clockwise, we revert them
    // G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
    //            JustWarning, 
    //            "Polygon vertices defined anti-clockwise, reverting polygon");
    std::reverse(fPolygon.begin(),fPolygon.end());
  }
  
  // Copy z-sections
  //
  fZSections.push_back(ZSection(-dz, off1, scale1));
  fZSections.push_back(ZSection( dz, off2, scale2));
    
  G4bool result = MakeFacets();
  if (!result)
  {   
    std::ostringstream message;
    message << "Making facets failed - " << pName;
    G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0003",
                FatalException, message);
  }
  fIsConvex = G4GeomTools::IsConvex(fPolygon);
 
  ComputeProjectionParameters();
 
  // Check if the solid is a right prism, if so then set lateral planes
  //
  if ((scale1 == 1) && (scale2 == 1)
      && (off1 == G4TwoVector(0,0)) && (off2 == G4TwoVector(0,0)))
  {
    fSolidType = (fIsConvex) ? 1 : 2; // 1 - convex, 2 - non-convex right prism
    ComputeLateralPlanes();
  }
}

References ComputeLateralPlanes(), ComputeProjectionParameters(), FatalErrorInArgument, FatalException, fIsConvex, fNv, fPolygon, fSolidType, fZSections, G4Exception(), G4GeomTools::IsConvex(), JustWarning, G4VSolid::kCarTolerance, MakeFacets(), G4GeomTools::PolygonArea(), and G4GeomTools::RemoveRedundantVertices().

◆ ~G4ExtrudedSolid()

G4ExtrudedSolid::~G4ExtrudedSolid ( )

virtual

Definition at line 333 of file G4ExtrudedSolid.cc.

{
  // Destructor
}

◆ G4ExtrudedSolid() [3/4]

G4ExtrudedSolid::G4ExtrudedSolid ( __void__ & a )

Definition at line 283 of file G4ExtrudedSolid.cc.

  : G4TessellatedSolid(a), fNv(0), fNz(0),
    fGeometryType("G4ExtrudedSolid")
{
  // Fake default constructor - sets only member data and allocates memory
  //                            for usage restricted to object persistency.
}

◆ G4ExtrudedSolid() [4/4]

G4ExtrudedSolid::G4ExtrudedSolid ( const G4ExtrudedSolid & rhs )

Definition at line 293 of file G4ExtrudedSolid.cc.

  : G4TessellatedSolid(rhs), fNv(rhs.fNv), fNz(rhs.fNz),
    fPolygon(rhs.fPolygon), fZSections(rhs.fZSections),
    fTriangles(rhs.fTriangles), fIsConvex(rhs.fIsConvex),
    fGeometryType(rhs.fGeometryType),
    fSolidType(rhs.fSolidType), fPlanes(rhs.fPlanes),
    fLines(rhs.fLines), fLengths(rhs.fLengths),
    fKScales(rhs.fKScales), fScale0s(rhs.fScale0s),
    fKOffsets(rhs.fKOffsets), fOffset0s(rhs.fOffset0s)
{
}

Member Function Documentation

◆ AddFacet()

G4bool G4TessellatedSolid::AddFacet ( G4VFacet * aFacet )

inherited

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 G4TessellatedSolid::fFacetList, G4TessellatedSolid::fFacets, G4TessellatedSolid::fSolidClosed, G4cout, G4Exception(), G4VFacet::GetCircumcentre(), G4VertexInfo::id, G4VFacet::IsDefined(), JustWarning, G4VSolid::kCarTolerance, G4VertexInfo::mag2, G4TessellatedSolid::OutsideOfExtent(), pos, G4VFacet::StreamInfo(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

◆ AddGeneralPolygonFacets()

G4bool G4ExtrudedSolid::AddGeneralPolygonFacets ( )

private

Definition at line 637 of file G4ExtrudedSolid.cc.

{
  // Decompose polygonal sides in triangular facets
 
  typedef std::pair < G4TwoVector, G4int > Vertex;
 
  static const G4double kAngTolerance =
    G4GeometryTolerance::GetInstance()->GetAngularTolerance();
 
  // Fill one more vector
  //
  std::vector< Vertex > verticesToBeDone;
  for ( G4int i=0; i<fNv; ++i )
  {
    verticesToBeDone.push_back(Vertex(fPolygon[i], i));
  }
  std::vector< Vertex > ears;
  
  std::vector< Vertex >::iterator c1 = verticesToBeDone.begin();
  std::vector< Vertex >::iterator c2 = c1+1;  
  std::vector< Vertex >::iterator c3 = c1+2;  
  while ( verticesToBeDone.size()>2 )    // Loop checking, 13.08.2015, G.Cosmo
  {
 
    // G4cout << "Looking at triangle : "
    //         << c1->second << "  " << c2->second
    //        << "  " << c3->second << G4endl;  
    //G4cout << "Looking at triangle : "
    //        << c1->first << "  " << c2->first
    //        << "  " << c3->first << G4endl;  
 
    // skip concave vertices
    //
    G4double angle = GetAngle(c2->first, c3->first, c1->first);
   
    //G4cout << "angle " << angle  << G4endl;
 
    G4int counter = 0;
    while ( angle >= (pi-kAngTolerance) )  // Loop checking, 13.08.2015, G.Cosmo
    {
      // G4cout << "Skipping concave vertex " << c2->second << G4endl;
 
      // try next three consecutive vertices
      //
      c1 = c2;
      c2 = c3;
      ++c3; 
      if ( c3 == verticesToBeDone.end() ) { c3 = verticesToBeDone.begin(); }
 
      //G4cout << "Looking at triangle : "
      //      << c1->first << "  " << c2->first
      //        << "  " << c3->first << G4endl; 
      
      angle = GetAngle(c2->first, c3->first, c1->first); 
      //G4cout << "angle " << angle  << G4endl;
      
      ++counter;
      
      if ( counter > fNv)
      {
        G4Exception("G4ExtrudedSolid::AddGeneralPolygonFacets",
                    "GeomSolids0003", FatalException,
                    "Triangularisation has failed.");
        break;
      }  
    }
 
    G4bool good = true;
    for ( auto it=verticesToBeDone.cbegin(); it!=verticesToBeDone.cend(); ++it )
    {
      // skip vertices of tested triangle
      //
      if ( it == c1 || it == c2 || it == c3 ) { continue; }
 
      if ( IsPointInside(c1->first, c2->first, c3->first, it->first) )
      {
        // G4cout << "Point " << it->second << " is inside" << G4endl;
        good = false;
 
        // try next three consecutive vertices
        //
        c1 = c2;
        c2 = c3;
        ++c3; 
        if ( c3 == verticesToBeDone.end() ) { c3 = verticesToBeDone.begin(); }
        break;
      }
      // else 
      //   { G4cout << "Point " << it->second << " is outside" << G4endl; }
    }
    if ( good )
    {
      // all points are outside triangle, we can make a facet
 
      // G4cout << "Found triangle : "
      //        << c1->second << "  " << c2->second
      //        << "  " << c3->second << G4endl;  
 
      G4bool result;
      result = AddFacet( MakeDownFacet(c1->second, c2->second, c3->second) );
      if ( ! result ) { return false; }
 
      result = AddFacet( MakeUpFacet(c1->second, c2->second, c3->second) );
      if ( ! result ) { return false; }
 
      std::vector<G4int> triangle(3);
      triangle[0] = c1->second;
      triangle[1] = c2->second;
      triangle[2] = c3->second;
      fTriangles.push_back(triangle);
 
      // remove the ear point from verticesToBeDone
      //
      verticesToBeDone.erase(c2);
      c1 = verticesToBeDone.begin();
      c2 = c1+1;  
      c3 = c1+2;  
    } 
  }
  return true;
}

References G4TessellatedSolid::AddFacet(), angle, FatalException, fNv, fPolygon, fTriangles, G4Exception(), GetAngle(), G4GeometryTolerance::GetAngularTolerance(), G4GeometryTolerance::GetInstance(), IsPointInside(), MakeDownFacet(), MakeUpFacet(), and pi.

Referenced by MakeFacets().

◆ AllocatedMemory()

G4int G4TessellatedSolid::AllocatedMemory ( )

inherited

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(), G4TessellatedSolid::AllocatedMemoryWithoutVoxels(), G4TessellatedSolid::fInsides, G4TessellatedSolid::fVoxels, and G4SurfBits::GetNbytes().

Referenced by G4TessellatedSolid::DisplayAllocatedMemory().

◆ AllocatedMemoryWithoutVoxels()

G4int G4TessellatedSolid::AllocatedMemoryWithoutVoxels ( )

inherited

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(), G4TessellatedSolid::fExtremeFacets, G4TessellatedSolid::fFacets, G4TessellatedSolid::fRandir, and G4TessellatedSolid::fVertexList.

Referenced by G4TessellatedSolid::AllocatedMemory(), and G4TessellatedSolid::DisplayAllocatedMemory().

◆ ApproxSurfaceNormal()

G4ThreeVector G4ExtrudedSolid::ApproxSurfaceNormal ( const G4ThreeVector & p ) const

private

Definition at line 1070 of file G4ExtrudedSolid.cc.

{
  // This method is valid only for right prisms and
  // normally should not be called
 
  if (fSolidType == 1 || fSolidType == 2)
  {
    // Find distances to z-planes
    //
    G4double dz0 = fZSections[0].fZ - p.z();
    G4double dz1 = p.z() - fZSections[1].fZ;
    G4double ddz0 = dz0*dz0;
    G4double ddz1 = dz1*dz1;
 
    // Find nearest lateral side and distance to it
    //
    G4int iside = 0;
    G4double dd = DBL_MAX;
    for (G4int i=0, k=fNv-1; i<fNv; k=i++)
    {
      G4double ix = p.x() - fPolygon[i].x();
      G4double iy = p.y() - fPolygon[i].y();
      G4double u  = fPlanes[i].a*iy - fPlanes[i].b*ix;
      if (u < 0)
      {
        G4double tmp = ix*ix + iy*iy;
        if (tmp < dd) { dd = tmp; iside = i; }
      }
      else if (u > fLengths[i])
      {
        G4double kx = p.x() - fPolygon[k].x();
        G4double ky = p.y() - fPolygon[k].y();
        G4double tmp = kx*kx + ky*ky;
        if (tmp < dd)  { dd = tmp; iside = i; }
      }
      else
      {
        G4double tmp = fPlanes[i].a*p.x() + fPlanes[i].b*p.y() + fPlanes[i].d;
        tmp *= tmp;
        if (tmp < dd)  { dd = tmp; iside = i; }
      }
    }
 
    // Find region
    //
    //  3  |   1   |  3
    // ----+-------+----
    //  2  |   0   |  2
    // ----+-------+----
    //  3  |   1   |  3
    //
    G4int iregion = 0;
    if (std::max(dz0,dz1) > 0) iregion = 1;
 
    G4bool in = PointInPolygon(p);
    if (!in) iregion += 2;
 
    // Return normal
    //
    switch (iregion)
    {
      case 0:
      {
        if (ddz0 <= ddz1 && ddz0 <= dd) return G4ThreeVector(0, 0,-1);
        if (ddz1 <= ddz0 && ddz1 <= dd) return G4ThreeVector(0, 0, 1);
        return G4ThreeVector(fPlanes[iside].a, fPlanes[iside].b, 0);
      }
      case 1:
      {
        return G4ThreeVector(0, 0, (dz0 > dz1) ? -1 : 1);
      }
      case 2:
      {
        return G4ThreeVector(fPlanes[iside].a, fPlanes[iside].b, 0);
      }
      case 3:
      {
        G4double dzmax = std::max(dz0,dz1);
        if (dzmax*dzmax > dd) return G4ThreeVector(0,0,(dz0 > dz1) ? -1 : 1);
        return G4ThreeVector(fPlanes[iside].a,fPlanes[iside].b, 0);
      }
    }
  }
  return G4ThreeVector(0,0,0);
}

References DBL_MAX, fLengths, fNv, fPlanes, fPolygon, fSolidType, fZSections, G4INCL::Math::max(), PointInPolygon(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by SurfaceNormal().

◆ BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 1371 of file G4ExtrudedSolid.cc.

{
  G4double xmin0 = kInfinity, xmax0 = -kInfinity;
  G4double ymin0 = kInfinity, ymax0 = -kInfinity;
 
  for (G4int i=0; i<GetNofVertices(); ++i)
  {
    G4double x = fPolygon[i].x();
    if (x < xmin0) xmin0 = x;
    if (x > xmax0) xmax0 = x;
    G4double y = fPolygon[i].y();
    if (y < ymin0) ymin0 = y;
    if (y > ymax0) ymax0 = y;
  }
 
  G4double xmin = kInfinity, xmax = -kInfinity;
  G4double ymin = kInfinity, ymax = -kInfinity;
 
  G4int nsect = GetNofZSections();
  for (G4int i=0; i<nsect; ++i)
  {
    ZSection zsect = GetZSection(i);
    G4double dx    = zsect.fOffset.x();
    G4double dy    = zsect.fOffset.y();
    G4double scale = zsect.fScale;
    xmin = std::min(xmin,xmin0*scale+dx);
    xmax = std::max(xmax,xmax0*scale+dx);
    ymin = std::min(ymin,ymin0*scale+dy);
    ymax = std::max(ymax,ymax0*scale+dy);
  }
 
  G4double zmin = GetZSection(0).fZ;
  G4double zmax = GetZSection(nsect-1).fZ;
 
  pMin.set(xmin,ymin,zmin);
  pMax.set(xmax,ymax,zmax);
 
  // 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("G4ExtrudedSolid::BoundingLimits()",
                "GeomMgt0001", JustWarning, message);
    DumpInfo();
  }
}

References G4VSolid::DumpInfo(), G4ExtrudedSolid::ZSection::fOffset, fPolygon, G4ExtrudedSolid::ZSection::fScale, G4ExtrudedSolid::ZSection::fZ, G4Exception(), G4VSolid::GetName(), GetNofVertices(), GetNofZSections(), GetZSection(), JustWarning, kInfinity, G4INCL::Math::max(), G4INCL::Math::min(), pMax, pMin, CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

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 G4ExtrudedSolid::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pMin,
		G4double &	pMax
	)		const

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1428 of file G4ExtrudedSolid.cc.

{
  G4ThreeVector bmin, bmax;
  G4bool exist;
 
  // Check bounding box (bbox)
  //
  BoundingLimits(bmin,bmax);
  G4BoundingEnvelope bbox(bmin,bmax);
#ifdef G4BBOX_EXTENT
  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
#endif
  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
  {
    return exist = (pMin < pMax) ? true : false;
  }
 
  // To find the extent, the base polygon is subdivided in triangles.
  // The extent is calculated as cumulative extent of the parts
  // formed by extrusion of the triangles
  //
  G4TwoVectorList triangles;
  G4double eminlim = pVoxelLimit.GetMinExtent(pAxis);
  G4double emaxlim = pVoxelLimit.GetMaxExtent(pAxis);
 
  // triangulate the base polygon
  if (!G4GeomTools::TriangulatePolygon(fPolygon,triangles))
  {
    std::ostringstream message;
    message << "Triangulation of the base polygon has failed for solid: "
            << GetName() << " !"
            << "\nExtent has been calculated using boundary box";
    G4Exception("G4ExtrudedSolid::CalculateExtent()",
                "GeomMgt1002",JustWarning,message);
    return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
  }
 
  // allocate vector lists
  G4int nsect = GetNofZSections();
  std::vector<const G4ThreeVectorList *> polygons;
  polygons.resize(nsect);
  for (G4int k=0; k<nsect; ++k) { polygons[k] = new G4ThreeVectorList(3); }
 
  // main loop along triangles
  pMin =  kInfinity;
  pMax = -kInfinity;
  G4int ntria = triangles.size()/3;
  for (G4int i=0; i<ntria; ++i)
  {
    G4int i3 = i*3;
    for (G4int k=0; k<nsect; ++k) // extrude triangle
    {
      ZSection zsect = GetZSection(k);
      G4double z     = zsect.fZ;
      G4double dx    = zsect.fOffset.x();
      G4double dy    = zsect.fOffset.y();
      G4double scale = zsect.fScale;
 
      G4ThreeVectorList* ptr = const_cast<G4ThreeVectorList*>(polygons[k]);
      G4ThreeVectorList::iterator iter = ptr->begin();
      G4double x0 = triangles[i3+0].x()*scale+dx;
      G4double y0 = triangles[i3+0].y()*scale+dy;
      iter->set(x0,y0,z);
      iter++;
      G4double x1 = triangles[i3+1].x()*scale+dx;
      G4double y1 = triangles[i3+1].y()*scale+dy;
      iter->set(x1,y1,z);
      iter++;
      G4double x2 = triangles[i3+2].x()*scale+dx;
      G4double y2 = triangles[i3+2].y()*scale+dy;
      iter->set(x2,y2,z);
    }
 
    // set sub-envelope and adjust extent
    G4double emin,emax;
    G4BoundingEnvelope benv(polygons);
    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
  }
  // free memory
  for (G4int k=0; k<nsect; ++k) { delete polygons[k]; polygons[k]=0;}
  return (pMin < pMax);
}

References G4BoundingEnvelope::BoundingBoxVsVoxelLimits(), BoundingLimits(), G4BoundingEnvelope::CalculateExtent(), emax, G4ExtrudedSolid::ZSection::fOffset, fPolygon, G4ExtrudedSolid::ZSection::fScale, G4ExtrudedSolid::ZSection::fZ, G4Exception(), G4VoxelLimits::GetMaxExtent(), G4VoxelLimits::GetMinExtent(), G4VSolid::GetName(), GetNofZSections(), GetZSection(), JustWarning, kInfinity, pMax, pMin, G4GeomTools::TriangulatePolygon(), CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

◆ CheckStructure()

G4int G4TessellatedSolid::CheckStructure ( ) const

inherited

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(), G4TessellatedSolid::fFacets, G4VFacet::GetArea(), G4VFacet::GetNumberOfVertices(), G4VFacet::GetSurfaceNormal(), G4VFacet::GetVertex(), and G4VFacet::GetVertexIndex().

Referenced by G4TessellatedSolid::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 * G4ExtrudedSolid::Clone ( ) const

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 850 of file G4ExtrudedSolid.cc.

{
  return new G4ExtrudedSolid(*this);
}

References G4ExtrudedSolid().

◆ CompareSortedVoxel()

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

staticprivateinherited

Definition at line 1585 of file G4TessellatedSolid.cc.

{
  return l.second < r.second;
}

Referenced by G4TessellatedSolid::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().

◆ ComputeLateralPlanes()

void G4ExtrudedSolid::ComputeLateralPlanes ( )

private

Definition at line 373 of file G4ExtrudedSolid.cc.

{
  // Compute lateral planes: a*x + b*y + c*z + d = 0
  //
  G4int Nv = fPolygon.size();
  fPlanes.resize(Nv);
  for (G4int i=0, k=Nv-1; i<Nv; k=i++)
  {
    G4TwoVector norm = (fPolygon[i] - fPolygon[k]).unit();
    fPlanes[i].a = -norm.y();
    fPlanes[i].b =  norm.x();
    fPlanes[i].c =  0;
    fPlanes[i].d =  norm.y()*fPolygon[i].x() - norm.x()*fPolygon[i].y();
  }
 
  // Compute edge equations: x = k*y + m
  // and edge lengths
  //
  fLines.resize(Nv);
  fLengths.resize(Nv);
  for (G4int i=0, k=Nv-1; i<Nv; k=i++)
  {
    if (fPolygon[k].y() == fPolygon[i].y())
    {
      fLines[i].k = 0;
      fLines[i].m = fPolygon[i].x();
    }
    else
    {
      G4double ctg = (fPolygon[k].x()-fPolygon[i].x())/(fPolygon[k].y()-fPolygon[i].y());
      fLines[i].k = ctg;
      fLines[i].m = fPolygon[i].x() - ctg*fPolygon[i].y();
    }
    fLengths[i]  =  (fPolygon[i] - fPolygon[k]).mag();
  }
}

References fLengths, fLines, fPlanes, fPolygon, CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by G4ExtrudedSolid().

◆ ComputeProjectionParameters()

void G4ExtrudedSolid::ComputeProjectionParameters ( )

private

Definition at line 340 of file G4ExtrudedSolid.cc.

{
  // Compute parameters for point projections p(z)
  // to the polygon scale & offset:
  // scale(z) = k*z + scale0
  // offset(z) = l*z + offset0
  // p(z) = scale(z)*p0 + offset(z)
  // p0 = (p(z) - offset(z))/scale(z);
  //
 
  for ( G4int iz=0; iz<fNz-1; ++iz)
  {
    G4double z1      = fZSections[iz].fZ;
    G4double z2      = fZSections[iz+1].fZ;
    G4double scale1  = fZSections[iz].fScale;
    G4double scale2  = fZSections[iz+1].fScale;
    G4TwoVector off1 = fZSections[iz].fOffset;
    G4TwoVector off2 = fZSections[iz+1].fOffset;
 
    G4double kscale = (scale2 - scale1)/(z2 - z1);
    G4double scale0 =  scale2 - kscale*(z2 - z1)/2.0;
    G4TwoVector koff = (off2 - off1)/(z2 - z1);
    G4TwoVector off0 =  off2 - koff*(z2 - z1)/2.0;
 
    fKScales.push_back(kscale);
    fScale0s.push_back(scale0);
    fKOffsets.push_back(koff);
    fOffset0s.push_back(off0);
  }
}

References fKOffsets, fKScales, fNz, fOffset0s, fScale0s, and fZSections.

Referenced by G4ExtrudedSolid().

◆ CopyObjects()

void G4TessellatedSolid::CopyObjects ( const G4TessellatedSolid & s )

privateinherited

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 G4TessellatedSolid::AddFacet(), G4TessellatedSolid::fVoxels, G4Voxelizer::GetMaxVoxels(), CLHEP::detail::n, G4Voxelizer::SetMaxVoxels(), G4TessellatedSolid::SetSolidClosed(), and geant4_check_module_cycles::ts.

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

◆ CreatePolyhedron()

G4Polyhedron * G4TessellatedSolid::CreatePolyhedron ( ) const

virtualinherited

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(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fVertexList, G4VFacet::GetNumberOfVertices(), G4VFacet::GetVertexIndex(), CLHEP::detail::n, and G4PolyhedronArbitrary::SetReferences().

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

◆ CreateVertexList()

void G4TessellatedSolid::CreateVertexList ( )

privateinherited

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 G4TessellatedSolid::fFacets, G4TessellatedSolid::fMaxExtent, G4TessellatedSolid::fMinExtent, G4TessellatedSolid::fVertexList, G4cout, G4endl, G4VFacet::GetNumberOfVertices(), G4VFacet::GetVertex(), G4VertexInfo::id, G4VSolid::kCarTolerance, G4VertexInfo::mag2, G4INCL::Math::max(), G4TessellatedSolid::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 G4TessellatedSolid::SetSolidClosed().

◆ DeleteObjects()

void G4TessellatedSolid::DeleteObjects ( )

privateinherited

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 G4TessellatedSolid::fFacets, and G4TessellatedSolid::fpPolyhedron.

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

◆ DescribeYourselfTo()

void G4TessellatedSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtualinherited

Implements G4VSolid.

Definition at line 1921 of file G4TessellatedSolid.cc.

{
  scene.AddSolid (*this);
}

References G4VGraphicsScene::AddSolid().

Referenced by G4GenericTrap::DescribeYourselfTo().

◆ DisplayAllocatedMemory()

void G4TessellatedSolid::DisplayAllocatedMemory ( )

inherited

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 G4TessellatedSolid::AllocatedMemory(), G4TessellatedSolid::AllocatedMemoryWithoutVoxels(), G4cout, and G4endl.

Referenced by G4TessellatedSolid::SetSolidClosed().

◆ DistanceToIn() [1/2]

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1219 of file G4ExtrudedSolid.cc.

{
  switch (fSolidType)
  {
    case 1: // convex right prism
    {
      G4double dist = std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
      G4int np = fPlanes.size();
      for (G4int i=0; i<np; ++i)
      {
        G4double dd = fPlanes[i].a*p.x() + fPlanes[i].b*p.y() + fPlanes[i].d;
        if (dd > dist) dist = dd;
      }
      return (dist > 0) ? dist : 0.;
    }
    case 2: // non-convex right prism
    {
      G4bool in = PointInPolygon(p);
      if (in)
      {
        G4double distz= std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
        return (distz > 0) ? distz : 0;
      }
      else
      {
        G4double distz= std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
        G4double dd = DistanceToPolygonSqr(p);
        if (distz > 0) dd += distz*distz;
        return std::sqrt(dd);
      }
    }
  }
 
  // General case: use tessellated solid
  return G4TessellatedSolid::DistanceToIn(p);
}

References G4TessellatedSolid::DistanceToIn(), DistanceToPolygonSqr(), fPlanes, fSolidType, fZSections, G4INCL::Math::max(), PointInPolygon(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ DistanceToIn() [2/2]

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1158 of file G4ExtrudedSolid.cc.

{
  G4double z0 = fZSections[0].fZ;
  G4double z1 = fZSections[fNz-1].fZ;
  if ((p.z() <= z0 + kCarToleranceHalf) && v.z() <= 0) return kInfinity;
  if ((p.z() >= z1 - kCarToleranceHalf) && v.z() >= 0) return kInfinity;
 
  switch (fSolidType)
  {
    case 1: // convex right prism
    {
      // Intersection with Z planes
      //
      G4double dz = (z1 - z0)*0.5;
      G4double pz = p.z() - dz - z0;
 
      G4double invz = (v.z() == 0) ? DBL_MAX : -1./v.z();
      G4double ddz = (invz < 0) ? dz : -dz;
      G4double tzmin = (pz + ddz)*invz;
      G4double tzmax = (pz - ddz)*invz;
 
      // Intersection with lateral planes
      //
      G4int np = fPlanes.size();
      G4double txmin = tzmin, txmax = tzmax;
      for (G4int i=0; i<np; ++i)
      { 
        G4double cosa = fPlanes[i].a*v.x()+fPlanes[i].b*v.y();
        G4double dist = fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].d;
        if (dist >= -kCarToleranceHalf)
        {
          if (cosa >= 0)  { return kInfinity; }
          G4double tmp  = -dist/cosa;
          if (txmin < tmp)  { txmin = tmp; }
        }
        else if (cosa > 0)
        {
          G4double tmp  = -dist/cosa;
          if (txmax > tmp)  { txmax = tmp; }
        } 
      }
 
      // Find distance
      //
      G4double tmin = txmin, tmax = txmax;
      if (tmax <= tmin + kCarToleranceHalf)   // touch or no hit
      {
        return kInfinity;
      }
      return (tmin < kCarToleranceHalf) ? 0. : tmin;
    }
    case 2: // non-convex right prism
    {
    }
  }
  return G4TessellatedSolid::DistanceToIn(p,v);
}

References DBL_MAX, G4TessellatedSolid::DistanceToIn(), fNz, fPlanes, fSolidType, fZSections, G4TessellatedSolid::kCarToleranceHalf, kInfinity, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), CLHEP::Hep3Vector::z(), and G4InuclParticleNames::z0.

◆ DistanceToInCandidates()

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

privateinherited

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 G4TessellatedSolid::fFacets, G4VFacet::Intersect(), G4TessellatedSolid::kCarToleranceHalf, kInfinity, and CLHEP::normal().

Referenced by G4TessellatedSolid::DistanceToInCore().

◆ DistanceToInCore()

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

privateinherited

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(), G4TessellatedSolid::DistanceToInCandidates(), G4TessellatedSolid::DistanceToInNoVoxels(), G4Voxelizer::DistanceToNext(), G4TessellatedSolid::fVoxels, G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4Voxelizer::GetVoxel(), G4VSolid::kCarTolerance, kInfinity, CLHEP::Hep3Vector::unit(), and G4Voxelizer::UpdateCurrentVoxel().

Referenced by G4TessellatedSolid::DistanceToIn().

◆ DistanceToInNoVoxels()

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

privateinherited

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 G4TessellatedSolid::DistanceToOut(), G4TessellatedSolid::fFacets, G4endl, G4Exception(), G4TessellatedSolid::Inside(), G4VFacet::Intersect(), JustWarning, G4TessellatedSolid::kCarToleranceHalf, kInfinity, kInside, mm, CLHEP::normal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TessellatedSolid::DistanceToInCore().

◆ DistanceToOut() [1/2]

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1340 of file G4ExtrudedSolid.cc.

{
  switch (fSolidType)
  {
    case 1: // convex right prism
    {
      G4double dist = std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
      G4int np = fPlanes.size();
      for (G4int i=0; i<np; ++i)
      {
        G4double dd = fPlanes[i].a*p.x() + fPlanes[i].b*p.y() + fPlanes[i].d;
        if (dd > dist) dist = dd;
      }
      return (dist < 0) ? -dist : 0.;
    }
    case 2: // non-convex right prism
    {
      G4double distz = std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
      G4bool in = PointInPolygon(p);
      if (distz >= 0 || (!in)) return 0; // point is outside
      return std::min(-distz,std::sqrt(DistanceToPolygonSqr(p)));
    }
  }
 
  // General case: use tessellated solid
  return G4TessellatedSolid::DistanceToOut(p);
}

References G4TessellatedSolid::DistanceToOut(), DistanceToPolygonSqr(), fPlanes, fSolidType, fZSections, G4INCL::Math::max(), G4INCL::Math::min(), PointInPolygon(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ DistanceToOut() [2/2]

G4double G4ExtrudedSolid::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = `false`,
		G4bool *	validNorm = `nullptr`,
		G4ThreeVector *	n = `nullptr`
	)		const

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1258 of file G4ExtrudedSolid.cc.

{
  G4bool getnorm = calcNorm;
  if (getnorm) *validNorm = true;
 
  G4double z0 = fZSections[0].fZ;
  G4double z1 = fZSections[fNz-1].fZ;
  if ((p.z() <= z0 + kCarToleranceHalf) && v.z() < 0)
  {
    if (getnorm) n->set(0,0,-1);
    return 0;
  }
  if ((p.z() >= z1 - kCarToleranceHalf) && v.z() > 0)
  {
    if (getnorm) n->set(0,0,1);
    return 0;
  }
 
  switch (fSolidType)
  {
    case 1: // convex right prism
    {
      // Intersection with Z planes
      //
      G4double dz = (z1 - z0)*0.5;
      G4double pz = p.z() - 0.5 * (z0 + z1);
 
      G4double vz = v.z();
      G4double tmax = (vz == 0) ? DBL_MAX : (std::copysign(dz,vz) - pz)/vz;
      G4int iside = (vz < 0) ? -4 : -2; // little trick: (-4+3)=-1, (-2+3)=+1
 
      // Intersection with lateral planes
      //
      G4int np = fPlanes.size();
      for (G4int i=0; i<np; ++i)
      {
        G4double cosa = fPlanes[i].a*v.x()+fPlanes[i].b*v.y();
        if (cosa > 0)
        {
          G4double dist = fPlanes[i].a*p.x()+fPlanes[i].b*p.y()+fPlanes[i].d;
          if (dist >= -kCarToleranceHalf)
          {
            if (getnorm) n->set(fPlanes[i].a, fPlanes[i].b, fPlanes[i].c);
            return 0;
          }
          G4double tmp = -dist/cosa;
          if (tmax > tmp) { tmax = tmp; iside = i; }
        }
      }
 
      // Set normal, if required, and return distance
      //
      if (getnorm)
      {
        if (iside < 0)
          { n->set(0, 0, iside + 3); } // (-4+3)=-1, (-2+3)=+1
        else
          { n->set(fPlanes[iside].a, fPlanes[iside].b, fPlanes[iside].c); }
      }
      return tmax;
    }
    case 2: // non-convex right prism
    {
    }
  }
 
  // Override the base class function to redefine validNorm
  // (the solid can be concave)
 
  G4double distOut =
    G4TessellatedSolid::DistanceToOut(p, v, calcNorm, validNorm, n);
  if (validNorm) { *validNorm = fIsConvex; }
 
  return distOut;
}

References DBL_MAX, G4TessellatedSolid::DistanceToOut(), fIsConvex, fNz, fPlanes, fSolidType, fZSections, G4TessellatedSolid::kCarToleranceHalf, CLHEP::detail::n, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), CLHEP::Hep3Vector::z(), and G4InuclParticleNames::z0.

◆ DistanceToOutCandidates()

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

privateinherited

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(), G4TessellatedSolid::fFacets, G4VFacet::Intersect(), G4VSolid::kCarTolerance, G4TessellatedSolid::kCarToleranceHalf, and CLHEP::normal().

Referenced by G4TessellatedSolid::DistanceToOutCore().

◆ DistanceToOutCore()

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

privateinherited

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(), G4TessellatedSolid::DistanceToOutCandidates(), G4TessellatedSolid::DistanceToOutNoVoxels(), G4TessellatedSolid::fExtremeFacets, G4TessellatedSolid::fFacets, G4TessellatedSolid::fVoxels, G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4Voxelizer::GetVoxel(), G4VSolid::kCarTolerance, kInfinity, G4TessellatedSolid::Normal(), CLHEP::Hep3Vector::unit(), and G4Voxelizer::UpdateCurrentVoxel().

Referenced by G4TessellatedSolid::DistanceToOut().

◆ DistanceToOutNoVoxels()

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

privateinherited

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(), G4TessellatedSolid::DistanceToIn(), G4TessellatedSolid::fExtremeFacets, G4TessellatedSolid::fFacets, G4endl, G4Exception(), G4TessellatedSolid::Inside(), G4VFacet::Intersect(), JustWarning, G4VSolid::kCarTolerance, G4TessellatedSolid::kCarToleranceHalf, kInfinity, kOutside, mm, G4TessellatedSolid::Normal(), CLHEP::normal(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TessellatedSolid::DistanceToOutCore().

◆ DistanceToPolygonSqr()

G4double G4ExtrudedSolid::DistanceToPolygonSqr ( const G4ThreeVector & p ) const

inlineprivate

Referenced by DistanceToIn(), DistanceToOut(), and Inside().

◆ 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().

◆ GetAngle()

G4double G4ExtrudedSolid::GetAngle	(	const G4TwoVector &	p0,
		const G4TwoVector &	pa,
		const G4TwoVector &	pb
	)		const

private

Definition at line 551 of file G4ExtrudedSolid.cc.

{
  // Return the angle of the vertex in po
 
  G4TwoVector t1 = pa - po;
  G4TwoVector t2 = pb - po;
  
  G4double result = (std::atan2(t1.y(), t1.x()) - std::atan2(t2.y(), t2.x()));
 
  if ( result < 0 ) result += 2*pi;
 
  return result;
}

References pi, CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by AddGeneralPolygonFacets().

◆ 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 ( )

virtualinherited

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(), G4TessellatedSolid::fCubicVolume, G4TessellatedSolid::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 G4ExtrudedSolid::GetEntityType ( ) const

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 841 of file G4ExtrudedSolid.cc.

{
  // Return entity type
 
  return fGeometryType;
}

References fGeometryType.

◆ GetExtent()

G4VisExtent G4TessellatedSolid::GetExtent ( ) const

virtualinherited

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 G4TessellatedSolid::fMaxExtent, G4TessellatedSolid::fMinExtent, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4GenericTrap::GetExtent().

◆ GetFacet()

G4VFacet * G4TessellatedSolid::GetFacet ( G4int i ) const

inlineinherited

Definition at line 304 of file G4TessellatedSolid.hh.

{
  return fFacets[i];
}

References G4TessellatedSolid::fFacets.

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

◆ GetFacetIndex()

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

inherited

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(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fVoxels, G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4Voxelizer::GetVoxel(), G4TessellatedSolid::kCarToleranceHalf, and kInfinity.

◆ GetMaxXExtent()

G4double G4TessellatedSolid::GetMaxXExtent ( ) const

inherited

Definition at line 2078 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.x();
}

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

Referenced by Inside().

◆ GetMaxYExtent()

G4double G4TessellatedSolid::GetMaxYExtent ( ) const

inherited

Definition at line 2092 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.y();
}

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

Referenced by Inside().

◆ GetMaxZExtent()

G4double G4TessellatedSolid::GetMaxZExtent ( ) const

inherited

Definition at line 2106 of file G4TessellatedSolid.cc.

{
  return fMaxExtent.z();
}

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

Referenced by Inside().

◆ GetMinXExtent()

G4double G4TessellatedSolid::GetMinXExtent ( ) const

inherited

Definition at line 2071 of file G4TessellatedSolid.cc.

{
  return fMinExtent.x();
}

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

Referenced by Inside().

◆ GetMinYExtent()

G4double G4TessellatedSolid::GetMinYExtent ( ) const

inherited

Definition at line 2085 of file G4TessellatedSolid.cc.

{
  return fMinExtent.y();
}

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

Referenced by Inside().

◆ GetMinZExtent()

G4double G4TessellatedSolid::GetMinZExtent ( ) const

inherited

Definition at line 2099 of file G4TessellatedSolid.cc.

{
  return fMinExtent.z();
}

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

Referenced by Inside().

◆ GetName()

G4String G4VSolid::GetName ( ) const

inlineinherited

◆ GetNofVertices()

G4int G4ExtrudedSolid::GetNofVertices ( ) const

inline

Referenced by BoundingLimits(), and G4GDMLWriteSolids::XtruWrite().

◆ GetNofZSections()

G4int G4ExtrudedSolid::GetNofZSections ( ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), and G4GDMLWriteSolids::XtruWrite().

◆ GetNumberOfFacets()

G4int G4TessellatedSolid::GetNumberOfFacets ( ) const

inherited

Definition at line 761 of file G4TessellatedSolid.cc.

{
  return fFacets.size();
}

References G4TessellatedSolid::fFacets.

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

◆ GetPointOnSurface()

G4ThreeVector G4TessellatedSolid::GetPointOnSurface ( ) const

virtualinherited

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 G4TessellatedSolid::fFacets, and G4INCL::DeJongSpin::shoot().

Referenced by G4GenericTrap::GetPointOnSurface().

◆ GetPolygon()

std::vector< G4TwoVector > G4ExtrudedSolid::GetPolygon ( ) const

inline

◆ GetPolyhedron()

G4Polyhedron * G4TessellatedSolid::GetPolyhedron ( ) const

virtualinherited

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 G4TessellatedSolid::CreatePolyhedron(), G4TessellatedSolid::fpPolyhedron, G4TessellatedSolid::fRebuildPolyhedron, HepPolyhedron::GetNumberOfRotationSteps(), G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation(), anonymous_namespace{G4TessellatedSolid.cc}::polyhedronMutex, and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by G4GenericTrap::GetPolyhedron().

◆ GetSolidClosed()

G4bool G4TessellatedSolid::GetSolidClosed ( ) const

inherited

Definition at line 662 of file G4TessellatedSolid.cc.

{
  return fSolidClosed;
}

References G4TessellatedSolid::fSolidClosed.

◆ GetSurfaceArea()

G4double G4TessellatedSolid::GetSurfaceArea ( )

virtualinherited

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 G4TessellatedSolid::fFacets, G4TessellatedSolid::fSurfaceArea, and G4VFacet::GetArea().

◆ GetTolerance()

G4double G4VSolid::GetTolerance ( ) const

inlineinherited

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

◆ GetVertex() [1/2]

G4TwoVector G4ExtrudedSolid::GetVertex ( G4int index ) const

inline

Referenced by MakeDownFacet(), MakeFacets(), MakeUpFacet(), and G4GDMLWriteSolids::XtruWrite().

◆ GetVertex() [2/2]

G4ThreeVector G4ExtrudedSolid::GetVertex	(	G4int	iz,
		G4int	ind
	)		const

private

Definition at line 412 of file G4ExtrudedSolid.cc.

{
  // Shift and scale vertices
 
  return G4ThreeVector( fPolygon[ind].x() * fZSections[iz].fScale
                      + fZSections[iz].fOffset.x(), 
                        fPolygon[ind].y() * fZSections[iz].fScale
                      + fZSections[iz].fOffset.y(), fZSections[iz].fZ);
}       

References fPolygon, and fZSections.

◆ GetVoxels()

G4Voxelizer & G4TessellatedSolid::GetVoxels ( )

inlineinherited

Definition at line 314 of file G4TessellatedSolid.hh.

{
  return fVoxels;
}

References G4TessellatedSolid::fVoxels.

◆ GetZSection()

ZSection G4ExtrudedSolid::GetZSection ( G4int index ) const

inline

Referenced by BoundingLimits(), CalculateExtent(), and G4GDMLWriteSolids::XtruWrite().

◆ GetZSections()

std::vector< ZSection > G4ExtrudedSolid::GetZSections ( ) const

inline

◆ Initialize()

void G4TessellatedSolid::Initialize ( )

privateinherited

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 G4TessellatedSolid::fCubicVolume, G4TessellatedSolid::fGeometryType, G4TessellatedSolid::fMaxExtent, G4TessellatedSolid::fMinExtent, G4TessellatedSolid::fpPolyhedron, G4TessellatedSolid::fRebuildPolyhedron, G4TessellatedSolid::fSolidClosed, G4TessellatedSolid::fSurfaceArea, G4VSolid::kCarTolerance, G4TessellatedSolid::kCarToleranceHalf, kInfinity, CLHEP::Hep3Vector::set(), and G4TessellatedSolid::SetRandomVectors().

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

◆ Inside()

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 857 of file G4ExtrudedSolid.cc.

{
  switch (fSolidType)
  {
    case 1: // convex right prism
    {
      G4double dist = std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
      if (dist > kCarToleranceHalf)  { return kOutside; }
 
      G4int np = fPlanes.size();
      for (G4int i=0; i<np; ++i)
      {
        G4double dd = fPlanes[i].a*p.x() + fPlanes[i].b*p.y() + fPlanes[i].d;
        if (dd > dist)  { dist = dd; }
      }
      if (dist > kCarToleranceHalf)  { return kOutside; }
      return (dist > -kCarToleranceHalf) ? kSurface : kInside;
    }
    case 2: // non-convex right prism
    {
      G4double distz = std::max(fZSections[0].fZ-p.z(),p.z()-fZSections[1].fZ);
      if (distz > kCarToleranceHalf)  { return kOutside; }
 
      G4bool in = PointInPolygon(p);
      if (distz > -kCarToleranceHalf && in) { return kSurface; }
 
      G4double dd = DistanceToPolygonSqr(p) - kCarToleranceHalf*kCarToleranceHalf;
      if (in)
      {
        return (dd >= 0) ? kInside : kSurface;
      }
      else
      {
        return (dd > 0) ? kOutside : kSurface;
      }
    }
  }
 
  // Override the base class function  as it fails in case of concave polygon.
  // Project the point in the original polygon scale and check if it is inside
  // for each triangle.
 
  // Check first if outside extent
  //
  if ( p.x() < GetMinXExtent() - kCarToleranceHalf ||
       p.x() > GetMaxXExtent() + kCarToleranceHalf ||
       p.y() < GetMinYExtent() - kCarToleranceHalf ||
       p.y() > GetMaxYExtent() + kCarToleranceHalf ||
       p.z() < GetMinZExtent() - kCarToleranceHalf ||
       p.z() > GetMaxZExtent() + kCarToleranceHalf )
  {
    // G4cout << "G4ExtrudedSolid::Outside extent: " << p << G4endl;
    return kOutside;
  }
 
  // Project point p(z) to the polygon scale p0
  //
  G4TwoVector pscaled = ProjectPoint(p);
  
  // Check if on surface of polygon
  //
  for ( G4int i=0; i<fNv; ++i )
  {
    G4int j = (i+1) % fNv;
    if ( IsSameLineSegment(pscaled, fPolygon[i], fPolygon[j]) )
    {
      // G4cout << "G4ExtrudedSolid::Inside return Surface (on polygon) "
      //        << G4endl;
 
      return kSurface;
    }
  }
 
  // Now check if inside triangles
  //
  auto it = fTriangles.cbegin();
  G4bool inside = false;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    if ( IsPointInside(fPolygon[(*it)[0]], fPolygon[(*it)[1]],
                       fPolygon[(*it)[2]], pscaled) )  { inside = true; }
    ++it;
  } while ( (inside == false) && (it != fTriangles.cend()) );
 
  if ( inside )
  {
    // Check if on surface of z sides
    //
    if ( std::fabs( p.z() - fZSections[0].fZ ) < kCarToleranceHalf ||
         std::fabs( p.z() - fZSections[fNz-1].fZ ) < kCarToleranceHalf )
    {
      // G4cout << "G4ExtrudedSolid::Inside return Surface (on z side)"
      //        << G4endl;
 
      return kSurface;
    }
 
    // G4cout << "G4ExtrudedSolid::Inside return Inside" << G4endl;
 
    return kInside;
  }
 
  // G4cout << "G4ExtrudedSolid::Inside return Outside " << G4endl;
 
  return kOutside;
}

References DistanceToPolygonSqr(), fNv, fNz, fPlanes, fPolygon, fSolidType, fTriangles, fZSections, G4TessellatedSolid::GetMaxXExtent(), G4TessellatedSolid::GetMaxYExtent(), G4TessellatedSolid::GetMaxZExtent(), G4TessellatedSolid::GetMinXExtent(), G4TessellatedSolid::GetMinYExtent(), G4TessellatedSolid::GetMinZExtent(), IsPointInside(), IsSameLineSegment(), G4TessellatedSolid::kCarToleranceHalf, kInside, kOutside, kSurface, G4INCL::Math::max(), PointInPolygon(), ProjectPoint(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ InsideNoVoxels()

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

privateinherited

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(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fGeometryType, G4TessellatedSolid::fMaxTries, G4TessellatedSolid::fRandir, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, G4VSolid::kCarTolerance, G4TessellatedSolid::kCarToleranceHalf, kInfinity, kInside, kOutside, kSurface, mm, G4TessellatedSolid::OutsideOfExtent(), G4InuclParticleNames::sm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TessellatedSolid::Inside(), and G4TessellatedSolid::PrecalculateInsides().

◆ InsideVoxels()

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

privateinherited

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(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fGeometryType, G4TessellatedSolid::fInsides, G4TessellatedSolid::fMaxTries, G4TessellatedSolid::fRandir, G4TessellatedSolid::fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCandidates(), G4VSolid::GetName(), G4SurfBits::GetNbits(), G4Voxelizer::GetPointIndex(), G4Voxelizer::GetVoxel(), G4Voxelizer::GetVoxelsIndex(), G4VFacet::Intersect(), JustWarning, G4VSolid::kCarTolerance, G4TessellatedSolid::kCarToleranceHalf, kInfinity, kInside, kOutside, kSurface, mm, G4TessellatedSolid::OutsideOfExtent(), G4InuclParticleNames::sm, CLHEP::Hep3Vector::unit(), G4Voxelizer::UpdateCurrentVoxel(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TessellatedSolid::Inside().

◆ IsPointInside()

G4bool G4ExtrudedSolid::IsPointInside	(	const G4TwoVector &	a,
		const G4TwoVector &	b,
		const G4TwoVector &	c,
		const G4TwoVector &	p
	)		const

private

Definition at line 520 of file G4ExtrudedSolid.cc.

{
  // Return true if p is inside of triangle abc or on its edges, 
  // else returns false 
 
  // Check extent first
  //
  if ( ( p.x() < a.x() && p.x() < b.x() && p.x() < c.x() ) || 
       ( p.x() > a.x() && p.x() > b.x() && p.x() > c.x() ) || 
       ( p.y() < a.y() && p.y() < b.y() && p.y() < c.y() ) || 
       ( p.y() > a.y() && p.y() > b.y() && p.y() > c.y() ) ) return false;
  
  G4bool inside 
    = IsSameSide(p, a, b, c)
      && IsSameSide(p, b, a, c)
      && IsSameSide(p, c, a, b);
 
  G4bool onEdge
    = IsSameLineSegment(p, a, b)
      || IsSameLineSegment(p, b, c)
      || IsSameLineSegment(p, c, a);
      
  return inside || onEdge;    
}     

References IsSameLineSegment(), IsSameSide(), CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by AddGeneralPolygonFacets(), and Inside().

◆ IsSameLine()

G4bool G4ExtrudedSolid::IsSameLine	(	const G4TwoVector &	p,
		const G4TwoVector &	l1,
		const G4TwoVector &	l2
	)		const

private

Definition at line 455 of file G4ExtrudedSolid.cc.

{
  // Return true if p is on the line through l1, l2 
 
  if ( l1.x() == l2.x() )
  {
    return std::fabs(p.x() - l1.x()) < kCarToleranceHalf; 
  }
   G4double slope= ((l2.y() - l1.y())/(l2.x() - l1.x())); 
   G4double predy= l1.y() +  slope *(p.x() - l1.x()); 
   G4double dy= p.y() - predy; 
 
   // Calculate perpendicular distance
   //
   // G4double perpD= std::fabs(dy) / std::sqrt( 1 + slope * slope ); 
   // G4bool   simpleComp= (perpD<kCarToleranceHalf); 
 
   // Check perpendicular distance vs tolerance 'directly'
   //
   G4bool squareComp = (dy*dy < (1+slope*slope)
                     * kCarToleranceHalf * kCarToleranceHalf); 
 
   // return  simpleComp; 
   return squareComp;
}                    

References G4TessellatedSolid::kCarToleranceHalf, CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by IsSameLineSegment().

◆ IsSameLineSegment()

G4bool G4ExtrudedSolid::IsSameLineSegment	(	const G4TwoVector &	p,
		const G4TwoVector &	l1,
		const G4TwoVector &	l2
	)		const

private

Definition at line 485 of file G4ExtrudedSolid.cc.

{
  // Return true if p is on the line through l1, l2 and lies between
  // l1 and l2 
 
  if ( p.x() < std::min(l1.x(), l2.x()) - kCarToleranceHalf || 
       p.x() > std::max(l1.x(), l2.x()) + kCarToleranceHalf ||
       p.y() < std::min(l1.y(), l2.y()) - kCarToleranceHalf || 
       p.y() > std::max(l1.y(), l2.y()) + kCarToleranceHalf )
  {
    return false;
  }
 
  return IsSameLine(p, l1, l2);
}

References IsSameLine(), G4TessellatedSolid::kCarToleranceHalf, G4INCL::Math::max(), G4INCL::Math::min(), CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by Inside(), and IsPointInside().

◆ IsSameSide()

G4bool G4ExtrudedSolid::IsSameSide	(	const G4TwoVector &	p1,
		const G4TwoVector &	p2,
		const G4TwoVector &	l1,
		const G4TwoVector &	l2
	)		const

private

Definition at line 505 of file G4ExtrudedSolid.cc.

{
  // Return true if p1 and p2 are on the same side of the line through l1, l2 
 
  return   ( (p1.x() - l1.x()) * (l2.y() - l1.y())
         - (l2.x() - l1.x()) * (p1.y() - l1.y()) )
         * ( (p2.x() - l1.x()) * (l2.y() - l1.y())
         - (l2.x() - l1.x()) * (p2.y() - l1.y()) ) > 0;
}       

References CLHEP::Hep2Vector::x(), and CLHEP::Hep2Vector::y().

Referenced by IsPointInside().

◆ MakeDownFacet()

G4VFacet * G4ExtrudedSolid::MakeDownFacet	(	G4int	ind1,
		G4int	ind2,
		G4int	ind3
	)		const

private

Definition at line 570 of file G4ExtrudedSolid.cc.

{
  // Create a triangular facet from the polygon points given by indices
  // forming the down side ( the normal goes in -z)
 
  std::vector<G4ThreeVector> vertices;
  vertices.push_back(GetVertex(0, ind1));
  vertices.push_back(GetVertex(0, ind2));
  vertices.push_back(GetVertex(0, ind3));
  
  // first vertex most left
  //
  G4ThreeVector cross 
    = (vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
  
  if ( cross.z() > 0.0 )
  {
    // vertices ordered clock wise has to be reordered
 
    // G4cout << "G4ExtrudedSolid::MakeDownFacet: reordering vertices " 
    //        << ind1 << ", " << ind2 << ", " << ind3 << G4endl; 
 
    G4ThreeVector tmp = vertices[1];
    vertices[1] = vertices[2];
    vertices[2] = tmp;
  }
  
  return new G4TriangularFacet(vertices[0], vertices[1],
                               vertices[2], ABSOLUTE);
}      

References ABSOLUTE, GetVertex(), and CLHEP::Hep3Vector::z().

Referenced by AddGeneralPolygonFacets().

◆ MakeFacets()

G4bool G4ExtrudedSolid::MakeFacets ( )

private

Definition at line 761 of file G4ExtrudedSolid.cc.

{
  // Define facets
 
  G4bool good;
  
  // Decomposition of polygonal sides in the facets
  //
  if ( fNv == 3 )
  {
    good = AddFacet( new G4TriangularFacet( GetVertex(0, 0), GetVertex(0, 1),
                                            GetVertex(0, 2), ABSOLUTE) );
    if ( ! good ) { return false; }
 
    good = AddFacet( new G4TriangularFacet( GetVertex(fNz-1, 2),
                                            GetVertex(fNz-1, 1),
                                            GetVertex(fNz-1, 0),
                                            ABSOLUTE) );
    if ( ! good ) { return false; }
    
    std::vector<G4int> triangle(3);
    triangle[0] = 0;
    triangle[1] = 1;
    triangle[2] = 2;
    fTriangles.push_back(triangle);
  }
  
  else if ( fNv == 4 )
  {
    good = AddFacet( new G4QuadrangularFacet( GetVertex(0, 0),GetVertex(0, 1),
                                              GetVertex(0, 2),GetVertex(0, 3),
                                              ABSOLUTE) );
    if ( ! good ) { return false; }
 
    good = AddFacet( new G4QuadrangularFacet( GetVertex(fNz-1, 3),
                                              GetVertex(fNz-1, 2), 
                                              GetVertex(fNz-1, 1),
                                              GetVertex(fNz-1, 0),
                                              ABSOLUTE) );
    if ( ! good ) { return false; }
 
    std::vector<G4int> triangle1(3);
    triangle1[0] = 0;
    triangle1[1] = 1;
    triangle1[2] = 2;
    fTriangles.push_back(triangle1);
 
    std::vector<G4int> triangle2(3);
    triangle2[0] = 0;
    triangle2[1] = 2;
    triangle2[2] = 3;
    fTriangles.push_back(triangle2);
  }  
  else
  {
    good = AddGeneralPolygonFacets();
    if ( ! good ) { return false; }
  }
    
  // The quadrangular sides
  //
  for ( G4int iz = 0; iz < fNz-1; ++iz ) 
  {
    for ( G4int i = 0; i < fNv; ++i )
    {
      G4int j = (i+1) % fNv;
      good = AddFacet( new G4QuadrangularFacet
                        ( GetVertex(iz, j), GetVertex(iz, i), 
                          GetVertex(iz+1, i), GetVertex(iz+1, j), ABSOLUTE) );
      if ( ! good ) { return false; }
    }
  }  
 
  SetSolidClosed(true);
 
  return good;
}

References ABSOLUTE, G4TessellatedSolid::AddFacet(), AddGeneralPolygonFacets(), fNv, fNz, fTriangles, GetVertex(), and G4TessellatedSolid::SetSolidClosed().

Referenced by G4ExtrudedSolid().

◆ MakeUpFacet()

G4VFacet * G4ExtrudedSolid::MakeUpFacet	(	G4int	ind1,
		G4int	ind2,
		G4int	ind3
	)		const

private

Definition at line 604 of file G4ExtrudedSolid.cc.

{
  // Creates a triangular facet from the polygon points given by indices
  // forming the upper side ( z>0 )
 
  std::vector<G4ThreeVector> vertices;
  vertices.push_back(GetVertex(fNz-1, ind1));
  vertices.push_back(GetVertex(fNz-1, ind2));
  vertices.push_back(GetVertex(fNz-1, ind3));
  
  // first vertex most left
  //
  G4ThreeVector cross 
    = (vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
  
  if ( cross.z() < 0.0 )
  {
    // vertices ordered clock wise has to be reordered
 
    // G4cout << "G4ExtrudedSolid::MakeUpFacet: reordering vertices " 
    //        << ind1 << ", " << ind2 << ", " << ind3 << G4endl; 
 
    G4ThreeVector tmp = vertices[1];
    vertices[1] = vertices[2];
    vertices[2] = tmp;
  }
  
  return new G4TriangularFacet(vertices[0], vertices[1],
                               vertices[2], ABSOLUTE);
}      

References ABSOLUTE, fNz, GetVertex(), and CLHEP::Hep3Vector::z().

Referenced by AddGeneralPolygonFacets().

◆ MinDistanceFacet()

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

privateinherited

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 G4TessellatedSolid::CompareSortedVoxel(), G4VFacet::Distance(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fVoxels, G4Voxelizer::GetVoxelBox(), G4Voxelizer::GetVoxelBoxCandidates(), G4Voxelizer::GetVoxelBoxesSize(), G4VoxelBox::hlen, kInfinity, G4Voxelizer::MinDistanceToBox(), and G4VoxelBox::pos.

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

◆ Normal()

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

virtualinherited

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(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4VFacet::GetSurfaceNormal(), G4Voxelizer::GetVoxel(), JustWarning, G4TessellatedSolid::kCarToleranceHalf, kInfinity, G4TessellatedSolid::MinDistanceFacet(), and CLHEP::Hep3Vector::z().

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

◆ operator+=()

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

inherited

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 G4TessellatedSolid::AddFacet(), G4VFacet::GetClone(), G4TessellatedSolid::GetFacet(), and G4TessellatedSolid::GetNumberOfFacets().

◆ operator=()

G4ExtrudedSolid & G4ExtrudedSolid::operator= ( const G4ExtrudedSolid & rhs )

Definition at line 307 of file G4ExtrudedSolid.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4TessellatedSolid::operator=(rhs);
 
   // Copy data
   //
   fNv = rhs.fNv; fNz = rhs.fNz;
   fPolygon = rhs.fPolygon; fZSections = rhs.fZSections;
   fTriangles = rhs.fTriangles; fIsConvex = rhs.fIsConvex;
   fGeometryType = rhs.fGeometryType;
   fSolidType = rhs.fSolidType; fPlanes = rhs.fPlanes;
   fLines = rhs.fLines; fLengths = rhs.fLengths;
   fKScales = rhs.fKScales; fScale0s = rhs.fScale0s;
   fKOffsets = rhs.fKOffsets; fOffset0s = rhs.fOffset0s;
 
   return *this;
}

References fGeometryType, fIsConvex, fKOffsets, fKScales, fLengths, fLines, fNv, fNz, fOffset0s, fPlanes, fPolygon, fScale0s, fSolidType, fTriangles, fZSections, and G4TessellatedSolid::operator=().

◆ operator==()

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

inlineinherited

◆ OutsideOfExtent()

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

inlineprivateinherited

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 G4TessellatedSolid::fMaxExtent, G4TessellatedSolid::fMinExtent, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

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

◆ PointInPolygon()

G4bool G4ExtrudedSolid::PointInPolygon ( const G4ThreeVector & p ) const

inlineprivate

Referenced by ApproxSurfaceNormal(), DistanceToIn(), DistanceToOut(), and Inside().

◆ PrecalculateInsides()

void G4TessellatedSolid::PrecalculateInsides ( )

privateinherited

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(), G4TessellatedSolid::fInsides, G4TessellatedSolid::fVoxels, G4Voxelizer::GetBoundary(), G4Voxelizer::GetVoxelsIndex(), G4TessellatedSolid::InsideNoVoxels(), G4Voxelizer::IsEmpty(), kInside, G4SurfBits::ResetBitNumber(), G4TessellatedSolid::SetAllUsingStack(), and G4SurfBits::SetBitNumber().

Referenced by G4TessellatedSolid::Voxelize().

◆ ProjectPoint()

G4TwoVector G4ExtrudedSolid::ProjectPoint ( const G4ThreeVector & point ) const

private

Definition at line 424 of file G4ExtrudedSolid.cc.

{
  // Project point in the polygon scale
  // scale(z) = k*z + scale0
  // offset(z) = l*z + offset0
  // p(z) = scale(z)*p0 + offset(z)  
  // p0 = (p(z) - offset(z))/scale(z);
  
  // Select projection (z-segment of the solid) according to p.z()
  //
  G4int iz = 0;
  while ( point.z() > fZSections[iz+1].fZ && iz < fNz-2 ) { ++iz; }
      // Loop checking, 13.08.2015, G.Cosmo
  
  G4double z0 = ( fZSections[iz+1].fZ + fZSections[iz].fZ )/2.0;
  G4TwoVector p2(point.x(), point.y());
  G4double pscale  = fKScales[iz]*(point.z()-z0) + fScale0s[iz];
  G4TwoVector poffset = fKOffsets[iz]*(point.z()-z0) + fOffset0s[iz];
  
  // G4cout << point << " projected to " 
  //        << iz << "-th z-segment polygon as "
  //        << (p2 - poffset)/pscale << G4endl;
 
  // pscale is always >0 as it is an interpolation between two
  // positive scale values
  //
  return (p2 - poffset)/pscale;
}  

References fKOffsets, fKScales, fNz, fOffset0s, fScale0s, fZSections, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), CLHEP::Hep3Vector::z(), and G4InuclParticleNames::z0.

Referenced by Inside().

◆ SafetyFromInside()

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

virtualinherited

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(), G4TessellatedSolid::DistanceToIn(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCountOfVoxels(), G4TessellatedSolid::Inside(), JustWarning, G4VSolid::kCarTolerance, kInfinity, kOutside, G4TessellatedSolid::MinDistanceFacet(), mm, G4TessellatedSolid::OutsideOfExtent(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TessellatedSolid::DistanceToOut().

◆ SafetyFromOutside()

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

virtualinherited

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(), G4TessellatedSolid::DistanceToOut(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fInsides, G4TessellatedSolid::fVoxels, G4endl, G4Exception(), G4Voxelizer::GetCandidates(), G4Voxelizer::GetCountOfVoxels(), G4SurfBits::GetNbits(), G4Voxelizer::GetPointIndex(), G4Voxelizer::GetVoxel(), G4TessellatedSolid::Inside(), JustWarning, G4VSolid::kCarTolerance, kInfinity, kInside, G4TessellatedSolid::MinDistanceFacet(), mm, G4TessellatedSolid::OutsideOfExtent(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4TessellatedSolid::DistanceToIn().

◆ SetAllUsingStack()

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

privateinherited

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 G4TessellatedSolid::fInsides, G4TessellatedSolid::fVoxels, G4Voxelizer::GetVoxelsIndex(), G4Voxelizer::IsEmpty(), G4INCL::Math::max(), pos, and G4SurfBits::SetBitNumber().

Referenced by G4TessellatedSolid::PrecalculateInsides().

◆ SetExtremeFacets()

void G4TessellatedSolid::SetExtremeFacets ( )

privateinherited

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 G4TessellatedSolid::fExtremeFacets, G4TessellatedSolid::fFacets, G4TessellatedSolid::fVertexList, and G4VFacet::IsInside().

Referenced by G4TessellatedSolid::SetSolidClosed().

◆ SetMaxVoxels()

void G4TessellatedSolid::SetMaxVoxels ( G4int max )

inlineinherited

Definition at line 309 of file G4TessellatedSolid.hh.

{
  fVoxels.SetMaxVoxels(max);
}

References G4TessellatedSolid::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 ( )

privateinherited

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 G4TessellatedSolid::fMaxTries, and G4TessellatedSolid::fRandir.

Referenced by G4TessellatedSolid::Initialize().

◆ SetSolidClosed()

void G4TessellatedSolid::SetSolidClosed ( const G4bool t )

inherited

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 G4TessellatedSolid::CheckStructure(), G4TessellatedSolid::CreateVertexList(), G4TessellatedSolid::DisplayAllocatedMemory(), G4TessellatedSolid::fSolidClosed, G4cout, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, G4TessellatedSolid::SetExtremeFacets(), and G4TessellatedSolid::Voxelize().

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

◆ StreamInfo()

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1519 of file G4ExtrudedSolid.cc.

{
  G4int oldprc = os.precision(16);
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid geometry type: " << fGeometryType  << G4endl;
 
  if ( fIsConvex) 
    { os << " Convex polygon; list of vertices:" << G4endl; }
  else  
    { os << " Concave polygon; list of vertices:" << G4endl; }
  
  for ( G4int i=0; i<fNv; ++i )
  {
    os << std::setw(5) << "#" << i 
       << "   vx = " << fPolygon[i].x()/mm << " mm" 
       << "   vy = " << fPolygon[i].y()/mm << " mm" << G4endl;
  }
  
  os << " Sections:" << G4endl;
  for ( G4int iz=0; iz<fNz; ++iz ) 
  {
    os << "   z = "   << fZSections[iz].fZ/mm          << " mm  "
       << "  x0= "    << fZSections[iz].fOffset.x()/mm << " mm  "
       << "  y0= "    << fZSections[iz].fOffset.y()/mm << " mm  " 
       << "  scale= " << fZSections[iz].fScale << G4endl;
  }     
 
/*
  // Triangles (for debugging)
  os << G4endl; 
  os << " Triangles:" << G4endl;
  os << " Triangle #   vertex1   vertex2   vertex3" << G4endl;
 
  G4int counter = 0;
  std::vector< std::vector<G4int> >::const_iterator it;
  for ( it = fTriangles.begin(); it != fTriangles.end(); it++ ) {
     std::vector<G4int> triangle = *it;
     os << std::setw(10) << counter++ 
        << std::setw(10) << triangle[0] << std::setw(10)  << triangle[1]
        << std::setw(10)  << triangle[2] 
        << G4endl;
  }          
*/
  os.precision(oldprc);
 
  return os;
}  

References fGeometryType, fIsConvex, fNv, fNz, fPolygon, fZSections, G4endl, G4VSolid::GetName(), and mm.

◆ SurfaceNormal()

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 966 of file G4ExtrudedSolid.cc.

{
  G4int nsurf = 0;
  G4double nx = 0, ny = 0, nz = 0;
  switch (fSolidType)
  {
    case 1: // convex right prism
    {
      if (std::abs(p.z() - fZSections[0].fZ) <= kCarToleranceHalf)
      {
        nz = -1; ++nsurf;
      }
      if (std::abs(p.z() - fZSections[1].fZ) <= kCarToleranceHalf)
      {
        nz =  1; ++nsurf;
      }
      for (G4int i=0; i<fNv; ++i)
      {
        G4double dd = fPlanes[i].a*p.x() + fPlanes[i].b*p.y() + fPlanes[i].d;
        if (std::abs(dd) > kCarToleranceHalf) continue;
        nx += fPlanes[i].a;
        ny += fPlanes[i].b;
        ++nsurf;
      }
      break;
    }
    case 2: // non-convex right prism
    {
      if (std::abs(p.z() - fZSections[0].fZ) <= kCarToleranceHalf)
      {
        nz = -1; ++nsurf;
      }
      if (std::abs(p.z() - fZSections[1].fZ) <= kCarToleranceHalf)
      {
        nz =  1; ++nsurf;
      }
 
      G4double sqrCarToleranceHalf = kCarToleranceHalf*kCarToleranceHalf;
      for (G4int i=0, k=fNv-1; i<fNv; k=i++)
      {
        G4double ix = p.x() - fPolygon[i].x();
        G4double iy = p.y() - fPolygon[i].y();
        G4double u  = fPlanes[i].a*iy - fPlanes[i].b*ix;
        if (u < 0)
        {
          if (ix*ix + iy*iy > sqrCarToleranceHalf) continue;
        }
        else if (u > fLengths[i])
        {
          G4double kx = p.x() - fPolygon[k].x();
          G4double ky = p.y() - fPolygon[k].y();
          if (kx*kx + ky*ky > sqrCarToleranceHalf) continue;
        }
        else
        {
          G4double dd = fPlanes[i].a*p.x() + fPlanes[i].b*p.y() + fPlanes[i].d;
          if (dd*dd > sqrCarToleranceHalf) continue;
        }
        nx += fPlanes[i].a;
        ny += fPlanes[i].b;
        ++nsurf;
      }
      break;
    }
    default:
    {
      return G4TessellatedSolid::SurfaceNormal(p);
    }
  }
 
  // Return normal (right prism)
  //
  if (nsurf == 1)
  {
    return G4ThreeVector(nx,ny,nz);
  }
  else if (nsurf != 0) // edge or corner
  {
    return G4ThreeVector(nx,ny,nz).unit();
  }
  else
  {
    // Point is not on the surface, compute approximate normal
    //
#ifdef G4CSGDEBUG
    std::ostringstream message;
    G4int oldprc = message.precision(16);
    message << "Point p is not on surface (!?) of solid: "
            << GetName() << G4endl;
    message << "Position:\n";
    message << "   p.x() = " << p.x()/mm << " mm\n";
    message << "   p.y() = " << p.y()/mm << " mm\n";
    message << "   p.z() = " << p.z()/mm << " mm";
    G4cout.precision(oldprc) ;
    G4Exception("G4TesselatedSolid::SurfaceNormal(p)", "GeomSolids1002",
                JustWarning, message );
    DumpInfo();
#endif
    return ApproxSurfaceNormal(p);
  }
}

References ApproxSurfaceNormal(), G4VSolid::DumpInfo(), fLengths, fNv, fPlanes, fPolygon, fSolidType, fZSections, G4cout, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, G4TessellatedSolid::kCarToleranceHalf, mm, G4TessellatedSolid::SurfaceNormal(), CLHEP::Hep3Vector::unit(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ Voxelize()

void G4TessellatedSolid::Voxelize ( )

privateinherited

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(), G4TessellatedSolid::fFacets, G4TessellatedSolid::fVoxels, G4cout, G4endl, G4SurfBits::GetNbits(), G4TessellatedSolid::PrecalculateInsides(), and G4Voxelizer::Voxelize().

Referenced by G4TessellatedSolid::SetSolidClosed().

Field Documentation

◆ fCubicVolume

G4double G4TessellatedSolid::fCubicVolume = 0.0

privateinherited

Definition at line 280 of file G4TessellatedSolid.hh.

Referenced by G4TessellatedSolid::GetCubicVolume(), and G4TessellatedSolid::Initialize().

◆ fExtremeFacets

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

privateinherited

Definition at line 276 of file G4TessellatedSolid.hh.

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

◆ fFacetList

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

privateinherited

Definition at line 285 of file G4TessellatedSolid.hh.

Referenced by G4TessellatedSolid::AddFacet().

◆ fFacets

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

privateinherited

Definition at line 275 of file G4TessellatedSolid.hh.

◆ fGeometryType

G4GeometryType G4ExtrudedSolid::fGeometryType

private

Definition at line 190 of file G4ExtrudedSolid.hh.

Referenced by GetEntityType(), operator=(), and StreamInfo().

◆ fInsides

G4SurfBits G4TessellatedSolid::fInsides

privateinherited

Definition at line 297 of file G4TessellatedSolid.hh.

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

◆ fIsConvex

G4bool G4ExtrudedSolid::fIsConvex = false

private

Definition at line 189 of file G4ExtrudedSolid.hh.

Referenced by DistanceToOut(), G4ExtrudedSolid(), operator=(), and StreamInfo().

◆ fKOffsets

std::vector<G4TwoVector> G4ExtrudedSolid::fKOffsets

private

Definition at line 201 of file G4ExtrudedSolid.hh.

Referenced by ComputeProjectionParameters(), operator=(), and ProjectPoint().

◆ fKScales

std::vector<G4double> G4ExtrudedSolid::fKScales

private

Definition at line 199 of file G4ExtrudedSolid.hh.

Referenced by ComputeProjectionParameters(), operator=(), and ProjectPoint().

◆ fLengths

std::vector<G4double> G4ExtrudedSolid::fLengths

private

Definition at line 197 of file G4ExtrudedSolid.hh.

Referenced by ApproxSurfaceNormal(), ComputeLateralPlanes(), operator=(), and SurfaceNormal().

◆ fLines

std::vector<line> G4ExtrudedSolid::fLines

private

Definition at line 196 of file G4ExtrudedSolid.hh.

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

◆ fMaxExtent

G4ThreeVector G4TessellatedSolid::fMaxExtent

privateinherited

Definition at line 287 of file G4TessellatedSolid.hh.

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

◆ fMaxTries

G4int G4TessellatedSolid::fMaxTries

privateinherited

Definition at line 293 of file G4TessellatedSolid.hh.

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

◆ fMinExtent

G4ThreeVector G4TessellatedSolid::fMinExtent

privateinherited

Definition at line 287 of file G4TessellatedSolid.hh.

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

◆ fNv

G4int G4ExtrudedSolid::fNv

private

Definition at line 184 of file G4ExtrudedSolid.hh.

Referenced by AddGeneralPolygonFacets(), ApproxSurfaceNormal(), G4ExtrudedSolid(), Inside(), MakeFacets(), operator=(), StreamInfo(), and SurfaceNormal().

◆ fNz

G4int G4ExtrudedSolid::fNz

private

Definition at line 185 of file G4ExtrudedSolid.hh.

Referenced by ComputeProjectionParameters(), DistanceToIn(), DistanceToOut(), G4ExtrudedSolid(), Inside(), MakeFacets(), MakeUpFacet(), operator=(), ProjectPoint(), and StreamInfo().

◆ fOffset0s

std::vector<G4TwoVector> G4ExtrudedSolid::fOffset0s

private

Definition at line 202 of file G4ExtrudedSolid.hh.

Referenced by ComputeProjectionParameters(), operator=(), and ProjectPoint().

◆ fPlanes

std::vector<plane> G4ExtrudedSolid::fPlanes

private

Definition at line 194 of file G4ExtrudedSolid.hh.

Referenced by ApproxSurfaceNormal(), ComputeLateralPlanes(), DistanceToIn(), DistanceToOut(), Inside(), operator=(), and SurfaceNormal().

◆ fPolygon

std::vector<G4TwoVector> G4ExtrudedSolid::fPolygon

private

Definition at line 186 of file G4ExtrudedSolid.hh.

Referenced by AddGeneralPolygonFacets(), ApproxSurfaceNormal(), BoundingLimits(), CalculateExtent(), ComputeLateralPlanes(), G4ExtrudedSolid(), GetVertex(), Inside(), operator=(), StreamInfo(), and SurfaceNormal().

◆ fpPolyhedron

G4Polyhedron* G4TessellatedSolid::fpPolyhedron = nullptr

mutableprivateinherited

Definition at line 273 of file G4TessellatedSolid.hh.

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

◆ fRandir

std::vector<G4ThreeVector> G4TessellatedSolid::fRandir

privateinherited

Definition at line 291 of file G4TessellatedSolid.hh.

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

◆ fRebuildPolyhedron

G4bool G4TessellatedSolid::fRebuildPolyhedron = false

mutableprivateinherited

Definition at line 272 of file G4TessellatedSolid.hh.

Referenced by G4TessellatedSolid::GetPolyhedron(), and G4TessellatedSolid::Initialize().

◆ fScale0s

std::vector<G4double> G4ExtrudedSolid::fScale0s

private

Definition at line 200 of file G4ExtrudedSolid.hh.

Referenced by ComputeProjectionParameters(), operator=(), and ProjectPoint().

◆ 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

privateinherited

Definition at line 289 of file G4TessellatedSolid.hh.

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

◆ fSolidType

G4int G4ExtrudedSolid::fSolidType = 0

private

Definition at line 192 of file G4ExtrudedSolid.hh.

Referenced by ApproxSurfaceNormal(), DistanceToIn(), DistanceToOut(), G4ExtrudedSolid(), Inside(), operator=(), and SurfaceNormal().

◆ fSurfaceArea

G4double G4TessellatedSolid::fSurfaceArea = 0.0

privateinherited

Definition at line 281 of file G4TessellatedSolid.hh.

Referenced by G4TessellatedSolid::GetSurfaceArea(), and G4TessellatedSolid::Initialize().

◆ fTriangles

std::vector< std::vector<G4int> > G4ExtrudedSolid::fTriangles

private

Definition at line 188 of file G4ExtrudedSolid.hh.

Referenced by AddGeneralPolygonFacets(), Inside(), MakeFacets(), and operator=().

◆ fVertexList

std::vector<G4ThreeVector> G4TessellatedSolid::fVertexList

privateinherited

Definition at line 283 of file G4TessellatedSolid.hh.

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

◆ fVoxels

G4Voxelizer G4TessellatedSolid::fVoxels

privateinherited

Definition at line 295 of file G4TessellatedSolid.hh.

◆ fZSections

std::vector<ZSection> G4ExtrudedSolid::fZSections

private

Definition at line 187 of file G4ExtrudedSolid.hh.

Referenced by ApproxSurfaceNormal(), ComputeProjectionParameters(), DistanceToIn(), DistanceToOut(), G4ExtrudedSolid(), GetVertex(), Inside(), operator=(), ProjectPoint(), StreamInfo(), and SurfaceNormal().

◆ kCarTolerance

G4double G4VSolid::kCarTolerance

protectedinherited

Definition at line 299 of file G4VSolid.hh.

◆ kCarToleranceHalf

G4double G4TessellatedSolid::kCarToleranceHalf

protectedinherited

Definition at line 268 of file G4TessellatedSolid.hh.

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

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

Data Structures

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4ExtrudedSolid() [1/4]

◆ G4ExtrudedSolid() [2/4]

◆ ~G4ExtrudedSolid()

◆ G4ExtrudedSolid() [3/4]

◆ G4ExtrudedSolid() [4/4]

Member Function Documentation

◆ AddFacet()

◆ AddGeneralPolygonFacets()

◆ AllocatedMemory()

◆ AllocatedMemoryWithoutVoxels()

◆ ApproxSurfaceNormal()

◆ BoundingLimits()

◆ CalculateClippedPolygonExtent()

◆ CalculateExtent()

◆ CheckStructure()

◆ ClipBetweenSections()

◆ ClipCrossSection()

◆ ClipPolygon()

◆ ClipPolygonToSimpleLimits()

◆ Clone()

◆ CompareSortedVoxel()

◆ ComputeDimensions()

◆ ComputeLateralPlanes()

◆ ComputeProjectionParameters()

◆ CopyObjects()

◆ CreatePolyhedron()

◆ CreateVertexList()

◆ DeleteObjects()

◆ DescribeYourselfTo()

◆ DisplayAllocatedMemory()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToInCandidates()

◆ DistanceToInCore()

◆ DistanceToInNoVoxels()

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ DistanceToOutCandidates()

◆ DistanceToOutCore()

◆ DistanceToOutNoVoxels()

◆ DistanceToPolygonSqr()

◆ DumpInfo()

◆ EstimateCubicVolume()

◆ EstimateSurfaceArea()

◆ GetAngle()

◆ GetConstituentSolid() [1/2]

◆ GetConstituentSolid() [2/2]

◆ GetCubicVolume()

◆ GetDisplacedSolidPtr() [1/2]

◆ GetDisplacedSolidPtr() [2/2]

◆ GetEntityType()

◆ GetExtent()

◆ GetFacet()

◆ GetFacetIndex()

◆ GetMaxXExtent()

◆ GetMaxYExtent()

◆ GetMaxZExtent()

◆ GetMinXExtent()

◆ GetMinYExtent()

◆ GetMinZExtent()

◆ GetName()

◆ GetNofVertices()

◆ GetNofZSections()

◆ GetNumberOfFacets()

◆ GetPointOnSurface()

◆ GetPolygon()

◆ GetPolyhedron()

◆ GetSolidClosed()

◆ GetSurfaceArea()

◆ GetTolerance()

◆ GetVertex() [1/2]