G4ExtrudedSolid Class Reference

#include <G4ExtrudedSolid.hh>

Inheritance diagram for G4ExtrudedSolid:

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)
Data Structures
struct	ZSection

---

Detailed Description

Definition at line 73 of file G4ExtrudedSolid.hh.

---

Constructor & Destructor Documentation

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

Definition at line 52 of file G4ExtrudedSolid.cc.

References FatalErrorInArgument, FatalException, G4Exception(), and G4VSolid::kCarTolerance.

Referenced by Clone().

  : 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 ) < kCarTolerance * 0.5 ) 
    {
      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();
}

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

Definition at line 151 of file G4ExtrudedSolid.cc.

References FatalErrorInArgument, FatalException, and G4Exception().

  : 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();
}

G4ExtrudedSolid::~G4ExtrudedSolid

(

)

[virtual]

Definition at line 272 of file G4ExtrudedSolid.cc.

{
  // Destructor
}

G4ExtrudedSolid::G4ExtrudedSolid

(

__void__ &

)

Definition at line 226 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::G4ExtrudedSolid

(

const G4ExtrudedSolid &

rhs

)

Definition at line 236 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

G4VSolid * G4ExtrudedSolid::Clone

(

)

const [virtual]

Reimplemented from G4TessellatedSolid.

Definition at line 753 of file G4ExtrudedSolid.cc.

References G4ExtrudedSolid().

{
  return new G4ExtrudedSolid(*this);
}

G4double G4ExtrudedSolid::DistanceToOut

(

const G4ThreeVector &

p

)

const [virtual]

Reimplemented from G4TessellatedSolid.

Definition at line 852 of file G4ExtrudedSolid.cc.

References G4TessellatedSolid::DistanceToOut().

{
  // Override the overloaded base class function

  return G4TessellatedSolid::DistanceToOut(p);
}

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 833 of file G4ExtrudedSolid.cc.

References G4TessellatedSolid::DistanceToOut().

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

G4GeometryType G4ExtrudedSolid::GetEntityType

(

)

const [virtual]

Reimplemented from G4TessellatedSolid.

Definition at line 744 of file G4ExtrudedSolid.cc.

{
  // Return entity type

  return fGeometryType;
}

G4int G4ExtrudedSolid::GetNofVertices

(

)

const [inline]

Definition at line 38 of file G4ExtrudedSolid.icc.

Referenced by G4GDMLWriteSolids::XtruWrite().

{
  return fNv;
}

G4int G4ExtrudedSolid::GetNofZSections

(

)

const [inline]

Definition at line 61 of file G4ExtrudedSolid.icc.

Referenced by G4GDMLWriteSolids::XtruWrite().

{
  return fNz;
}

std::vector< G4TwoVector > G4ExtrudedSolid::GetPolygon

(

)

const [inline]

Definition at line 55 of file G4ExtrudedSolid.icc.

{
  return fPolygon;
}  

G4TwoVector G4ExtrudedSolid::GetVertex

(

G4int

index

)

const [inline]

Definition at line 43 of file G4ExtrudedSolid.icc.

References FatalException, and G4Exception().

Referenced by G4GDMLWriteSolids::XtruWrite().

{
  if ( index<0 || index >= fNv )
  {
    G4Exception ("G4ExtrudedSolid::GetVertex()", "GeomSolids0003",
                 FatalException, "Index outside range.");
    return G4TwoVector();
  }
  return fPolygon[index];
}  

G4ExtrudedSolid::ZSection G4ExtrudedSolid::GetZSection

(

G4int

index

)

const [inline]

Definition at line 67 of file G4ExtrudedSolid.icc.

References FatalException, and G4Exception().

Referenced by G4GDMLWriteSolids::XtruWrite().

{
  if ( index<0 || index >= fNz )
  {
    G4Exception ("G4ExtrudedSolid::GetZSection()", "GeomSolids0003",
                 FatalException, "Index outside range.");
    return ZSection(0.0, G4TwoVector(), 0.0);
  }
  return fZSections[index];
}

std::vector< G4ExtrudedSolid::ZSection > G4ExtrudedSolid::GetZSections

(

)

const [inline]

Definition at line 79 of file G4ExtrudedSolid.icc.

{
  return fZSections;
}  

EInside G4ExtrudedSolid::Inside

(

const G4ThreeVector &

p

)

const [virtual]

Reimplemented from G4TessellatedSolid.

Definition at line 760 of file G4ExtrudedSolid.cc.

References G4TessellatedSolid::GetMaxXExtent(), G4TessellatedSolid::GetMaxYExtent(), G4TessellatedSolid::GetMaxZExtent(), G4TessellatedSolid::GetMinXExtent(), G4TessellatedSolid::GetMinYExtent(), G4TessellatedSolid::GetMinZExtent(), G4VSolid::kCarTolerance, kInside, kOutside, and 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() - kCarTolerance * 0.5 ||
       p.x() > GetMaxXExtent() + kCarTolerance * 0.5 ||
       p.y() < GetMinYExtent() - kCarTolerance * 0.5 ||
       p.y() > GetMaxYExtent() + kCarTolerance * 0.5 ||
       p.z() < GetMinZExtent() - kCarTolerance * 0.5 ||
       p.z() > GetMaxZExtent() + kCarTolerance * 0.5 )
  {
    // 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
  {
    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 ) < kCarTolerance * 0.5 ||
         std::fabs( p.z() - fZSections[fNz-1].fZ ) < kCarTolerance * 0.5 )
    {
      // 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; 
}  

G4ExtrudedSolid & G4ExtrudedSolid::operator=

(

const G4ExtrudedSolid &

rhs

)

Definition at line 248 of file G4ExtrudedSolid.cc.

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

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

std::ostream & G4ExtrudedSolid::StreamInfo

(

std::ostream &

os

)

const [virtual]

Reimplemented from G4TessellatedSolid.

Definition at line 861 of file G4ExtrudedSolid.cc.

References G4endl, and G4VSolid::GetName().

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

---

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

• G4ExtrudedSolid.hh
• G4ExtrudedSolid.icc
• G4ExtrudedSolid.cc

---