#include <G4ExtrudedSolid.hh>

Inheritance diagram for G4ExtrudedSolid:

Classes
struct	ZSection

Public Member Functions
	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=G4TwoVector(0., 0.), G4double scale1=1., const G4TwoVector &off2=G4TwoVector(0., 0.), G4double scale2=1.)

	~G4ExtrudedSolid () override

G4int	GetNofVertices () const

G4TwoVector	GetVertex (G4int index) const

std::vector< G4TwoVector >	GetPolygon () const

G4int	GetNofZSections () const

ZSection	GetZSection (G4int index) const

std::vector< ZSection >	GetZSections () const

EInside	Inside (const G4ThreeVector &p) const override

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override

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

G4double	DistanceToIn (const G4ThreeVector &p) const override

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

G4double	DistanceToOut (const G4ThreeVector &p) const override

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

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

G4GeometryType	GetEntityType () const override

G4bool	IsFaceted () const override

G4VSolid *	Clone () const override

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

	G4ExtrudedSolid (__void__ &)

	G4ExtrudedSolid (const G4ExtrudedSolid &rhs)

G4ExtrudedSolid &	operator= (const G4ExtrudedSolid &rhs)

Public Member Functions inherited from G4TessellatedSolid
	G4TessellatedSolid ()

	~G4TessellatedSolid () override

	G4TessellatedSolid (const G4String &name)

	G4TessellatedSolid (__void__ &)

	G4TessellatedSolid (const G4TessellatedSolid &ts)

G4TessellatedSolid &	operator= (const G4TessellatedSolid &right)

G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)

G4bool	AddFacet (G4VFacet *aFacet)

G4VFacet *	GetFacet (G4int i) const

G4int	GetNumberOfFacets () const

G4int	GetFacetIndex (const G4ThreeVector &p) const

EInside	Inside (const G4ThreeVector &p) const override

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override

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

G4double	DistanceToIn (const G4ThreeVector &p) const override

G4double	DistanceToOut (const G4ThreeVector &p) const override

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

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

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

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

G4GeometryType	GetEntityType () const override

G4bool	IsFaceted () const override

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

G4VSolid *	Clone () const override

G4ThreeVector	GetPointOnSurface () const override

G4double	GetSurfaceArea () override

G4double	GetCubicVolume () override

void	SetSolidClosed (const G4bool t)

G4bool	GetSolidClosed () const

G4int	CheckStructure () const

void	SetMaxVoxels (G4int max)

G4Voxelizer &	GetVoxels ()

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

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

G4double	GetMinXExtent () const

G4double	GetMaxXExtent () const

G4double	GetMinYExtent () const

G4double	GetMaxYExtent () const

G4double	GetMinZExtent () const

G4double	GetMaxZExtent () const

G4Polyhedron *	CreatePolyhedron () const override

G4Polyhedron *	GetPolyhedron () const override

void	DescribeYourselfTo (G4VGraphicsScene &scene) const override

G4VisExtent	GetExtent () const override

G4int	AllocatedMemoryWithoutVoxels ()

G4int	AllocatedMemory ()

void	DisplayAllocatedMemory ()

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

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

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

virtual G4int	GetNumOfConstituents () const

void	DumpInfo () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

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

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

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

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

Protected Attributes inherited from G4TessellatedSolid
G4double	kCarToleranceHalf

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

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 ( std::size_t 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.empty())
  {
    std::size_t 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 (std::size_t 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();
  }
}

Referenced by Clone(), G4ExtrudedSolid(), and operator=().

◆ G4ExtrudedSolid() [2/4]

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

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.empty())
  {
    std::size_t 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 (std::size_t 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.emplace_back(-dz, off1, scale1);
  fZSections.emplace_back( 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();
  }
}

◆ ~G4ExtrudedSolid()

G4ExtrudedSolid::~G4ExtrudedSolid ( )

override

Definition at line 322 of file G4ExtrudedSolid.cc.

{
  // Destructor
}

◆ G4ExtrudedSolid() [3/4]

G4ExtrudedSolid::G4ExtrudedSolid ( __void__ & a )

Definition at line 283 of file G4ExtrudedSolid.cc.

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

default

Member Function Documentation

◆ BoundingLimits()

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

overridevirtual

Reimplemented from G4VSolid.

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

Referenced by CalculateExtent().

◆ CalculateExtent()

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

overridevirtual

Implements G4VSolid.

Definition at line 1425 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;
  }
 
  // 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 = (G4int)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;
 
      auto ptr = const_cast<G4ThreeVectorList*>(polygons[k]);
      auto 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]=nullptr;}
  return (pMin < pMax);
}

◆ Clone()

G4VSolid * G4ExtrudedSolid::Clone ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 847 of file G4ExtrudedSolid.cc.

{
  return new G4ExtrudedSolid(*this);
}

◆ DistanceToIn() [1/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 1216 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);
      std::size_t np = fPlanes.size();
      for (std::size_t 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);
}

◆ DistanceToIn() [2/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 1155 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
      //
      std::size_t np = fPlanes.size();
      G4double txmin = tzmin, txmax = tzmax;
      for (std::size_t 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);
}

◆ DistanceToOut() [1/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 1337 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);
      std::size_t np = fPlanes.size();
      for (std::size_t 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);
}

◆ DistanceToOut() [2/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 1255 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
      //
      std::size_t np = fPlanes.size();
      for (std::size_t 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 = (G4int)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 != nullptr) { *validNorm = fIsConvex; }
 
  return distOut;
}

◆ GetEntityType()

G4GeometryType G4ExtrudedSolid::GetEntityType ( ) const

overridevirtual

Implements G4VSolid.

Definition at line 831 of file G4ExtrudedSolid.cc.

{
  // Return entity type
 
  return fGeometryType;
}

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

◆ GetPolygon()

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

inline

◆ GetVertex()

G4TwoVector G4ExtrudedSolid::GetVertex ( G4int index ) const

inline

Referenced by G4GDMLWriteSolids::XtruWrite().

◆ GetZSection()

ZSection G4ExtrudedSolid::GetZSection ( G4int index ) const

inline

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

◆ GetZSections()

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

inline

◆ Inside()

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

overridevirtual

Implements G4VSolid.

Definition at line 854 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; }
 
      std::size_t np = fPlanes.size();
      for (std::size_t 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<(G4int)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) && (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;
}

◆ IsFaceted()

G4bool G4ExtrudedSolid::IsFaceted ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 840 of file G4ExtrudedSolid.cc.

{
  return true;
}

◆ operator=()

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

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

◆ StreamInfo()

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

overridevirtual

Implements G4VSolid.

Definition at line 1516 of file G4ExtrudedSolid.cc.

{
  G4long 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 ( std::size_t 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 ( std::size_t 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;
}  

◆ SurfaceNormal()

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

overridevirtual

Implements G4VSolid.

Definition at line 963 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 (std::size_t 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 (std::size_t 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 { 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;
    G4long 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);
  }
}

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

Classes

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4ExtrudedSolid() [1/4]

◆ G4ExtrudedSolid() [2/4]

◆ ~G4ExtrudedSolid()

◆ G4ExtrudedSolid() [3/4]

◆ G4ExtrudedSolid() [4/4]

Member Function Documentation

◆ BoundingLimits()

◆ CalculateExtent()

◆ Clone()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetEntityType()

◆ GetNofVertices()

◆ GetNofZSections()

◆ GetPolygon()

◆ GetVertex()

◆ GetZSection()

◆ GetZSections()

◆ Inside()

◆ IsFaceted()

◆ operator=()

◆ StreamInfo()

◆ SurfaceNormal()