#include <G4ExtrudedSolid.hh>

Inheritance diagram for G4ExtrudedSolid:

Collaboration diagram for G4ExtrudedSolid:

Classes
struct	ZSection

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

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

virtual	~G4ExtrudedSolid ()

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

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

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4VSolid *	Clone () const

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

	G4ExtrudedSolid (__void__ &)

	G4ExtrudedSolid (const G4ExtrudedSolid &rhs)

G4ExtrudedSolid &	operator= (const G4ExtrudedSolid &rhs)

Public Member Functions inherited from G4TessellatedSolid
	G4TessellatedSolid ()

virtual	~G4TessellatedSolid ()

	G4TessellatedSolid (const G4String &name)

	G4TessellatedSolid (__void__ &)

	G4TessellatedSolid (const G4TessellatedSolid &ts)

G4TessellatedSolid &	operator= (const G4TessellatedSolid &right)

G4TessellatedSolid &	operator+= (const G4TessellatedSolid &right)

G4bool	AddFacet (G4VFacet *aFacet)

G4VFacet *	GetFacet (G4int i) const

G4int	GetNumberOfFacets () const

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

virtual G4double	DistanceToIn (const G4ThreeVector &p) const

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

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

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

virtual G4ThreeVector	GetPointOnSurface () const

virtual G4double	GetSurfaceArea ()

virtual G4double	GetCubicVolume ()

void	SetSolidClosed (const G4bool t)

G4bool	GetSolidClosed () const

void	SetMaxVoxels (G4int max)

G4SurfaceVoxelizer &	GetVoxels ()

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

G4double	GetMinXExtent () const

G4double	GetMaxXExtent () const

G4double	GetMinYExtent () const

G4double	GetMaxYExtent () const

G4double	GetMinZExtent () const

G4double	GetMaxZExtent () const

G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pT) const

virtual G4Polyhedron *	CreatePolyhedron () const

virtual G4Polyhedron *	GetPolyhedron () const

virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const

virtual G4VisExtent	GetExtent () const

G4int	AllocatedMemoryWithoutVoxels ()

G4int	AllocatedMemory ()

void	DisplayAllocatedMemory ()

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

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

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

void	DumpInfo () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Private Member Functions
void	ComputeProjectionParameters ()

G4ThreeVector	GetVertex (G4int iz, G4int ind) const

G4TwoVector	ProjectPoint (const G4ThreeVector &point) const

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

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

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

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

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

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

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

G4bool	AddGeneralPolygonFacets ()

G4bool	MakeFacets ()

G4bool	IsConvex () const

Private Attributes
G4int	fNv

G4int	fNz

std::vector< G4TwoVector >	fPolygon

std::vector< ZSection >	fZSections

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

G4bool	fIsConvex

G4GeometryType	fGeometryType

std::vector< G4double >	fKScales

std::vector< G4double >	fScale0s

std::vector< G4TwoVector >	fKOffsets

std::vector< G4TwoVector >	fOffset0s

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 82 of file G4ExtrudedSolid.hh.

Constructor & Destructor Documentation

◆ G4ExtrudedSolid() [1/4]

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

Definition at line 56 of file G4ExtrudedSolid.cc.

   : G4TessellatedSolid(pName),
     fNv(polygon.size()),
     fNz(zsections.size()),
     fPolygon(),
     fZSections(),
     fTriangles(),
     fIsConvex(false),
     fGeometryType("G4ExtrudedSolid")
     
 {
   // General constructor 
 
   // First check input parameters
 
   if ( fNv < 3 )
   {
     std::ostringstream message;
     message << "Number of polygon vertices < 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);
     }
   }  
   
   // Check if polygon vertices are defined clockwise
   // (the area is positive if polygon vertices are defined anti-clockwise)
   //
   G4double area = 0.;
   for ( G4int i=0; i<fNv; ++i ) {
     G4int j = i+1;
     if ( j == fNv ) j = 0;
     area += 0.5 * ( polygon[i].x()*polygon[j].y() - polygon[j].x()*polygon[i].y());
   }
  
   // Copy polygon
   //
   if  ( area < 0. ) {   
     // Polygon vertices are defined clockwise, we just copy the polygon       
     for ( G4int i=0; i<fNv; ++i ) { fPolygon.push_back(polygon[i]); }
   }
   else {
     // Polygon vertices are defined anti-clockwise, we revert them
     //G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
     //            JustWarning, 
     //            "Polygon vertices defined anti-clockwise, reverting polygon");      
     for ( G4int i=0; i<fNv; ++i ) { fPolygon.push_back(polygon[fNv-i-1]); }
   }
     
   
   // Copy z-sections
   //
   for ( G4int i=0; i<fNz; ++i ) { fZSections.push_back(zsections[i]); }
     
 
   G4bool result = MakeFacets();
   if (!result)
   {   
     std::ostringstream message;
     message << "Making facets failed - " << pName;
     G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0003",
                 FatalException, message);
   }
   fIsConvex = IsConvex();
 
   
   ComputeProjectionParameters();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ G4ExtrudedSolid() [2/4]

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

Definition at line 155 of file G4ExtrudedSolid.cc.

   : G4TessellatedSolid(pName),
     fNv(polygon.size()),
     fNz(2),
     fPolygon(),
     fZSections(),
     fTriangles(),
     fIsConvex(false),
     fGeometryType("G4ExtrudedSolid")
     
 {
   // Special constructor for solid with 2 z-sections
 
   // First check input parameters
   //
   if ( fNv < 3 )
   {
     std::ostringstream message;
     message << "Number of polygon vertices < 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)
   
   G4double area = 0.;
   for ( G4int i=0; i<fNv; ++i )
   {
     G4int j = i+1;
     if ( j == fNv )  { j = 0; }
     area += 0.5 * ( polygon[i].x()*polygon[j].y()
                   - polygon[j].x()*polygon[i].y());
   }
  
   // Copy polygon
   //
   if  ( area < 0. )
   {   
     // Polygon vertices are defined clockwise, we just copy the polygon       
     for ( G4int i=0; i<fNv; ++i ) { fPolygon.push_back(polygon[i]); }
   }
   else
   {
     // Polygon vertices are defined anti-clockwise, we revert them
     //G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
     //            JustWarning, 
     //            "Polygon vertices defined anti-clockwise, reverting polygon");      
     for ( G4int i=0; i<fNv; ++i ) { fPolygon.push_back(polygon[fNv-i-1]); }
   }
   
   // 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 = IsConvex();
 
   ComputeProjectionParameters();
 }

Here is the call graph for this function:

◆ ~G4ExtrudedSolid()

G4ExtrudedSolid::~G4ExtrudedSolid ( )

virtual

Definition at line 276 of file G4ExtrudedSolid.cc.

 {
   // Destructor
 }

◆ G4ExtrudedSolid() [3/4]

G4ExtrudedSolid::G4ExtrudedSolid ( __void__ & a )

Definition at line 230 of file G4ExtrudedSolid.cc.

   : G4TessellatedSolid(a), fNv(0), fNz(0), fPolygon(), fZSections(),
     fTriangles(), fIsConvex(false), 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 240 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), fKScales(rhs.fKScales),
     fScale0s(rhs.fScale0s), fKOffsets(rhs.fKOffsets), fOffset0s(rhs.fOffset0s)
 {
 }

Member Function Documentation

◆ AddGeneralPolygonFacets()

G4bool G4ExtrudedSolid::AddGeneralPolygonFacets ( )

private

Definition at line 535 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;
     std::vector< Vertex >::iterator it;
     for ( it=verticesToBeDone.begin(); it != verticesToBeDone.end(); ++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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clone()

G4VSolid * G4ExtrudedSolid::Clone ( ) const

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 765 of file G4ExtrudedSolid.cc.

 {
   return new G4ExtrudedSolid(*this);
 }

Here is the call graph for this function:

◆ ComputeProjectionParameters()

void G4ExtrudedSolid::ComputeProjectionParameters ( )

private

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

Here is the caller graph for this function:

◆ DistanceToOut() [1/2]

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 845 of file G4ExtrudedSolid.cc.

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

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 864 of file G4ExtrudedSolid.cc.

 {
   // Override the overloaded base class function
 
   return G4TessellatedSolid::DistanceToOut(p);
 }

Here is the call graph for this function:

◆ GetAngle()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetEntityType()

G4GeometryType G4ExtrudedSolid::GetEntityType ( ) const

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 756 of file G4ExtrudedSolid.cc.

 {
   // Return entity type
 
   return fGeometryType;
 }

◆ GetNofVertices()

G4int G4ExtrudedSolid::GetNofVertices ( ) const

inline

Here is the caller graph for this function:

◆ GetNofZSections()

G4int G4ExtrudedSolid::GetNofZSections ( ) const

inline

Here is the caller graph for this function:

◆ GetPolygon()

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

inline

◆ GetVertex() [1/2]

G4TwoVector G4ExtrudedSolid::GetVertex ( G4int index ) const

inline

Here is the caller graph for this function:

◆ GetVertex() [2/2]

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

private

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

◆ GetZSection()

ZSection G4ExtrudedSolid::GetZSection ( G4int index ) const

inline

Here is the caller graph for this function:

◆ GetZSections()

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

inline

◆ Inside()

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

virtual

Reimplemented from G4TessellatedSolid.

Definition at line 772 of file G4ExtrudedSolid.cc.

 {
   // 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
   //
   std::vector< std::vector<G4int> >::const_iterator it = fTriangles.begin();
   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.end()) );
   
   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; 
 }  

Here is the call graph for this function:

◆ IsConvex()

G4bool G4ExtrudedSolid::IsConvex ( ) const

private

Definition at line 735 of file G4ExtrudedSolid.cc.

 {
   // Get polygon convexity (polygon is convex if all vertex angles are < pi )
 
   for ( G4int i=0; i< fNv; ++i )
   {
     G4int j = ( i + 1 ) % fNv;
     G4int k = ( i + 2 ) % fNv;
     G4TwoVector v1 = fPolygon[i]-fPolygon[j];
     G4TwoVector v2 = fPolygon[k]-fPolygon[j];
     G4double dphi = v2.phi() - v1.phi();
     if ( dphi < 0. )  { dphi += 2.*pi; }
     
     if ( dphi >= pi ) { return false; }
   }
   
   return true;
 }     

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsPointInside()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsSameLine()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsSameLineSegment()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsSameSide()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeDownFacet()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeFacets()

G4bool G4ExtrudedSolid::MakeFacets ( )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeUpFacet()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

Definition at line 252 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; fKScales = rhs.fKScales;
    fScale0s = rhs.fScale0s; fKOffsets = rhs.fKOffsets;
    fOffset0s = rhs.fOffset0s;
 
    return *this;
 }

Here is the call graph for this function:

◆ ProjectPoint()

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

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StreamInfo()

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

virtual

Reimplemented from G4TessellatedSolid.

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

Here is the call graph for this function:

Member Data Documentation

◆ fGeometryType

G4GeometryType G4ExtrudedSolid::fGeometryType

private

Definition at line 181 of file G4ExtrudedSolid.hh.

◆ fIsConvex

G4bool G4ExtrudedSolid::fIsConvex

private

Definition at line 180 of file G4ExtrudedSolid.hh.

◆ fKOffsets

std::vector<G4TwoVector> G4ExtrudedSolid::fKOffsets

private

Definition at line 185 of file G4ExtrudedSolid.hh.

◆ fKScales

std::vector<G4double> G4ExtrudedSolid::fKScales

private

Definition at line 183 of file G4ExtrudedSolid.hh.

◆ fNv

G4int G4ExtrudedSolid::fNv

private

Definition at line 175 of file G4ExtrudedSolid.hh.

◆ fNz

G4int G4ExtrudedSolid::fNz

private

Definition at line 176 of file G4ExtrudedSolid.hh.

◆ fOffset0s

std::vector<G4TwoVector> G4ExtrudedSolid::fOffset0s

private

Definition at line 186 of file G4ExtrudedSolid.hh.

◆ fPolygon

std::vector<G4TwoVector> G4ExtrudedSolid::fPolygon

private

Definition at line 177 of file G4ExtrudedSolid.hh.

◆ fScale0s

std::vector<G4double> G4ExtrudedSolid::fScale0s

private

Definition at line 184 of file G4ExtrudedSolid.hh.

◆ fTriangles

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

private

Definition at line 179 of file G4ExtrudedSolid.hh.

◆ fZSections

std::vector<ZSection> G4ExtrudedSolid::fZSections

private

Definition at line 178 of file G4ExtrudedSolid.hh.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4ExtrudedSolid() [1/4]

◆ G4ExtrudedSolid() [2/4]

◆ ~G4ExtrudedSolid()

◆ G4ExtrudedSolid() [3/4]

◆ G4ExtrudedSolid() [4/4]

Member Function Documentation

◆ AddGeneralPolygonFacets()

◆ Clone()

◆ ComputeProjectionParameters()

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetAngle()

◆ GetEntityType()

◆ GetNofVertices()

◆ GetNofZSections()

◆ GetPolygon()

◆ GetVertex() [1/2]

◆ GetVertex() [2/2]

◆ GetZSection()

◆ GetZSections()

◆ Inside()

◆ IsConvex()

◆ IsPointInside()

◆ IsSameLine()

◆ IsSameLineSegment()

◆ IsSameSide()

◆ MakeDownFacet()

◆ MakeFacets()

◆ MakeUpFacet()

◆ operator=()

◆ ProjectPoint()

◆ StreamInfo()

Member Data Documentation

◆ fGeometryType

◆ fIsConvex

◆ fKOffsets

◆ fKScales

◆ fNv

◆ fNz

◆ fOffset0s

◆ fPolygon

◆ fScale0s

◆ fTriangles

◆ fZSections