G4PolyhedraSide Class Reference

G4PolyhedraSide is a utility class implementing a face that represents one segmented side of a polyhedra. More...

#include <G4PolyhedraSide.hh>

Inheritance diagram for G4PolyhedraSide:

Public Member Functions
	G4PolyhedraSide (const G4PolyhedraSideRZ *prevRZ, const G4PolyhedraSideRZ *tail, const G4PolyhedraSideRZ *head, const G4PolyhedraSideRZ *nextRZ, G4int numSide, G4double phiStart, G4double phiTotal, G4bool phiIsOpen, G4bool isAllBehind=false)
	~G4PolyhedraSide () override
	G4PolyhedraSide (const G4PolyhedraSide &source)
G4PolyhedraSide &	operator= (const G4PolyhedraSide &source)
G4bool	Intersect (const G4ThreeVector &p, const G4ThreeVector &v, G4bool outgoing, G4double surfTolerance, G4double &distance, G4double &distFromSurface, G4ThreeVector &normal, G4bool &allBehind) override
G4double	Distance (const G4ThreeVector &p, G4bool outgoing) override
EInside	Inside (const G4ThreeVector &p, G4double tolerance, G4double *bestDistance) override
G4ThreeVector	Normal (const G4ThreeVector &p, G4double *bestDistance) override
G4double	Extent (const G4ThreeVector axis) override
void	CalculateExtent (const EAxis axis, const G4VoxelLimits &voxelLimit, const G4AffineTransform &tranform, G4SolidExtentList &extentList) override
G4VCSGface *	Clone () override
G4double	SurfaceArea () override
	G4PolyhedraSide (__void__ &)
G4int	GetInstanceID () const
Public Member Functions inherited from G4VCSGface
	G4VCSGface ()=default
virtual	~G4VCSGface ()=default

Static Public Member Functions
static const G4PhSideManager &	GetSubInstanceManager ()

Friends
struct	sG4PolyhedraSideVec

Detailed Description

G4PolyhedraSide is a utility class implementing a face that represents one segmented side of a polyhedra.

Definition at line 90 of file G4PolyhedraSide.hh.

Constructor & Destructor Documentation

G4PolyhedraSide() [1/3]

G4PolyhedraSide::G4PolyhedraSide	(	const G4PolyhedraSideRZ *	prevRZ,
		const G4PolyhedraSideRZ *	tail,
		const G4PolyhedraSideRZ *	head,
		const G4PolyhedraSideRZ *	nextRZ,
		G4int	numSide,
		G4double	phiStart,
		G4double	phiTotal,
		G4bool	phiIsOpen,
		G4bool	isAllBehind = false )

Constructor for the segmented side of a polyhedra.

Parameters

[in]	prevRZ	Pointer to previous r,Z section.
[in]	tail	Pointer to r,Z tail of section.
[in]	head	Pointer to r,Z head of section.
[in]	nextRZ	Pointer to next r,Z section.
[in]	numSide	The number od sides.
[in]	phiStart	Initial Phi starting angle.
[in]	phiTotal	Total Phi angle.
[in]	phiIsOpen	Flag indicating if it is a Phi section.
[in]	isAllBehind	Indicating if entire surface is behind normal.

Definition at line 66 of file G4PolyhedraSide.cc.

{
  instanceID = subInstanceManager.CreateSubInstance();
 
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  G4MT_phphix = 0.0; G4MT_phphiy = 0.0; G4MT_phphiz = 0.0;
  G4MT_phphik = 0.0;
 
  //
  // Record values
  //
  r[0] = tail->r; z[0] = tail->z;
  r[1] = head->r; z[1] = head->z;
  
  G4double phiTotal;
  
  //
  // Set phi to our convention
  //
  startPhi = thePhiStart;
  while (startPhi < 0.0)    // Loop checking, 13.08.2015, G.Cosmo
  {
    startPhi += twopi;
  }
  
  phiIsOpen = thePhiIsOpen;
  phiTotal = (phiIsOpen) ? thePhiTotal : twopi;
  
  allBehind = isAllBehind;
    
  //
  // Make our intersecting cone
  //
  cone = new G4IntersectingCone( r, z );
  
  //
  // Construct side plane vector set
  //
  numSide = theNumSide>0 ? theNumSide : 1;
  deltaPhi = phiTotal/numSide;
  endPhi = startPhi+phiTotal;
 
  const std::size_t maxSides = numSide;
  vecs = new G4PolyhedraSideVec[maxSides];
  edges = new G4PolyhedraSideEdge[phiIsOpen ? maxSides+1 : maxSides];
  
  //
  // ...this is where we start
  //
  G4double phi = startPhi;
  G4ThreeVector a1( r[0]*std::cos(phi), r[0]*std::sin(phi), z[0] ),
          b1( r[1]*std::cos(phi), r[1]*std::sin(phi), z[1] ),
          c1( prevRZ->r*std::cos(phi), prevRZ->r*std::sin(phi), prevRZ->z ),
          d1( nextRZ->r*std::cos(phi), nextRZ->r*std::sin(phi), nextRZ->z ),
          a2, b2, c2, d2;
  G4PolyhedraSideEdge *edge = edges;
          
  G4PolyhedraSideVec *vec = vecs;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    //
    // ...this is where we are going
    //
    phi += deltaPhi;
    a2 = G4ThreeVector( r[0]*std::cos(phi), r[0]*std::sin(phi), z[0] );
    b2 = G4ThreeVector( r[1]*std::cos(phi), r[1]*std::sin(phi), z[1] );
    c2 = G4ThreeVector( prevRZ->r*std::cos(phi), prevRZ->r*std::sin(phi), prevRZ->z );
    d2 = G4ThreeVector( nextRZ->r*std::cos(phi), nextRZ->r*std::sin(phi), nextRZ->z );
    
    G4ThreeVector tt;  
    
    //
    // ...build some relevant vectors.
    //    the point is to sacrifice a little memory with precalcs 
    //    to gain speed
    //
    vec->center = 0.25*( a1 + a2 + b1 + b2 );
    
    tt = b2 + b1 - a2 - a1;
    vec->surfRZ = tt.unit();
    if (vec==vecs) { lenRZ = 0.25*tt.mag(); }
    
    tt = b2 - b1 + a2 - a1;
    vec->surfPhi = tt.unit();
    if (vec==vecs)
    {
      lenPhi[0] = 0.25*tt.mag();
      tt = b2 - b1;
      lenPhi[1] = (0.5*tt.mag()-lenPhi[0])/lenRZ;
    }
    
    tt = vec->surfPhi.cross(vec->surfRZ);
    vec->normal = tt.unit();
    
    //
    // ...edge normals are the average of the normals of
    //    the two faces they connect.
    //
    // ...edge normals are necessary if we are to accurately
    //    decide if a point is "inside" a face. For non-convex
    //    shapes, it is absolutely necessary to know information
    //    on adjacent faces to accurate determine this.
    //
    // ...we don't need them for the phi edges, since that
    //    information is taken care of internally. The r/z edges,
    //    however, depend on the adjacent G4PolyhedraSide.
    //
    G4ThreeVector a12, adj;
    
    a12 = a2-a1;
 
    adj = 0.5*(c1+c2-a1-a2);
    adj = adj.cross(a12);  
    adj = adj.unit() + vec->normal;       
    vec->edgeNorm[0] = adj.unit();
    
    a12 = b1-b2;
    adj = 0.5*(d1+d2-b1-b2);
    adj = adj.cross(a12);  
    adj = adj.unit() + vec->normal;       
    vec->edgeNorm[1] = adj.unit();
    
    //
    // ...the corners are crucial. It is important that
    //    they are calculated consistently for adjacent
    //    G4PolyhedraSides, to avoid gaps caused by roundoff.
    //
    vec->edges[0] = edge;
    edge->corner[0] = a1;
    edge->corner[1] = b1;
    edge++;
    vec->edges[1] = edge;
 
    a1 = a2;
    b1 = b2;
    c1 = c2;
    d1 = d2;
  } while( ++vec < vecs+maxSides );
  
  //
  // Clean up hanging edge
  //
  if (phiIsOpen)
  {
    edge->corner[0] = a2;
    edge->corner[1] = b2;
  }
  else
  {
    vecs[maxSides-1].edges[1] = edges;
  }
  
  //
  // Go back and fill in remaining fields in edges
  //
  vec = vecs;
  G4PolyhedraSideVec *prev = vecs+maxSides-1;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    edge = vec->edges[0];    // The edge between prev and vec
    
    //
    // Okay: edge normal is average of normals of adjacent faces
    //
    G4ThreeVector eNorm = vec->normal + prev->normal;
    edge->normal = eNorm.unit();  
    
    //
    // Vertex normal is average of norms of adjacent surfaces (all four)
    // However, vec->edgeNorm is unit vector in some direction
    // as the sum of normals of adjacent PolyhedraSide with vec.
    // The normalization used for this vector should be the same
    // for vec and prev.
    //
    eNorm = vec->edgeNorm[0] + prev->edgeNorm[0];
    edge->cornNorm[0] = eNorm.unit();
  
    eNorm = vec->edgeNorm[1] + prev->edgeNorm[1];
    edge->cornNorm[1] = eNorm.unit();
  } while( prev=vec, ++vec < vecs + maxSides );
  
  if (phiIsOpen)
  {
    // G4double rFact = std::cos(0.5*deltaPhi);
    //
    // If phi is open, we need to patch up normals of the
    // first and last edges and their corresponding
    // vertices.
    //
    // We use vectors that are in the plane of the
    // face. This should be safe.
    //
    vec = vecs;
    
    G4ThreeVector normvec = vec->edges[0]->corner[0]
                          - vec->edges[0]->corner[1];
    normvec = normvec.cross(vec->normal);
    if (normvec.dot(vec->surfPhi) > 0) { normvec = -normvec; }
 
    vec->edges[0]->normal = normvec.unit();
    
    vec->edges[0]->cornNorm[0] = (vec->edges[0]->corner[0]
                                - vec->center).unit();
    vec->edges[0]->cornNorm[1] = (vec->edges[0]->corner[1]
                                - vec->center).unit();
    
    //
    // Repeat for ending phi
    //
    vec = vecs + maxSides - 1;
    
    normvec = vec->edges[1]->corner[0] - vec->edges[1]->corner[1];
    normvec = normvec.cross(vec->normal);
    if (normvec.dot(vec->surfPhi) < 0) { normvec = -normvec; }
 
    vec->edges[1]->normal = normvec.unit();
    
    vec->edges[1]->cornNorm[0] = (vec->edges[1]->corner[0]
                                - vec->center).unit();
    vec->edges[1]->cornNorm[1] = (vec->edges[1]->corner[1]
                                - vec->center).unit();
  }
  
  //
  // edgeNorm is the factor one multiplies the distance along vector phi
  // on the surface of one of our sides in order to calculate the distance
  // from the edge. (see routine DistanceAway)
  //
  edgeNorm = 1.0/std::sqrt( 1.0 + lenPhi[1]*lenPhi[1] );
}

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

~G4PolyhedraSide()

G4PolyhedraSide::~G4PolyhedraSide ( )

override

Destructor.

Definition at line 320 of file G4PolyhedraSide.cc.

{
  delete cone;
  delete [] vecs;
  delete [] edges;
}

G4PolyhedraSide() [2/3]

G4PolyhedraSide::G4PolyhedraSide

(

const G4PolyhedraSide &

source

)

Copy constructor and assignment operator.

Definition at line 329 of file G4PolyhedraSide.cc.

{
  instanceID = subInstanceManager.CreateSubInstance();
 
  CopyStuff( source );
}

G4PolyhedraSide() [3/3]

G4PolyhedraSide::G4PolyhedraSide

(

__void__ &

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 308 of file G4PolyhedraSide.cc.

  : startPhi(0.), deltaPhi(0.), endPhi(0.),
    lenRZ(0.), edgeNorm(0.), kCarTolerance(0.), instanceID(0)
{
  r[0] = r[1] = 0.;
  z[0] = z[1] = 0.;
  lenPhi[0] = lenPhi[1] = 0.;
}

Member Function Documentation

CalculateExtent()

void G4PolyhedraSide::CalculateExtent ( const EAxis axis, const G4VoxelLimits & voxelLimit, const G4AffineTransform & tranform, G4SolidExtentList & extentList )

overridevirtual

Calculates the extent of the face for the voxel navigator.

Parameters

[in]	axis	The axis in which to check the shapes 3D extent against.
[in]	voxelLimit	Limits along x, y, and/or z axes.
[in]	tranform	A coordinate transformation on which to apply to the shape before testing.
[out]	extentList	The list of (voxel) extents along the axis.

Implements G4VCSGface.

Definition at line 706 of file G4PolyhedraSide.cc.

{
  //
  // Loop over all sides
  //
  G4PolyhedraSideVec *vec = vecs;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    //
    // Fill our polygon with the four corners of
    // this side, after the specified transformation
    //
    G4ClippablePolygon polygon;
    
    polygon.AddVertexInOrder(transform.
                             TransformPoint(vec->edges[0]->corner[0]));
    polygon.AddVertexInOrder(transform.
                             TransformPoint(vec->edges[0]->corner[1]));
    polygon.AddVertexInOrder(transform.
                             TransformPoint(vec->edges[1]->corner[1]));
    polygon.AddVertexInOrder(transform.
                             TransformPoint(vec->edges[1]->corner[0]));
    
    //
    // Get extent
    //  
    if (polygon.PartialClip( voxelLimit, axis ))
    {
      //
      // Get dot product of normal along target axis
      //
      polygon.SetNormal( transform.TransformAxis(vec->normal) );
 
      extentList.AddSurface( polygon );
    }
  } while( ++vec < vecs+numSide );
  
  return;
}

Clone()

G4VCSGface * G4PolyhedraSide::Clone ( )

inlineoverridevirtual

Method invoked by the copy constructor or the assignment operator. Its purpose is to return a pointer to a duplicate copy of the face.

Implements G4VCSGface.

Definition at line 203 of file G4PolyhedraSide.hh.

{ return new G4PolyhedraSide( *this ); }

Distance()

G4double G4PolyhedraSide::Distance ( const G4ThreeVector & p, G4bool outgoing )

overridevirtual

Determines the distance of a point from either the inside or outside surfaces of the face.

Parameters

[in]	p	Position.
[in]	outgoing	Flag, true, to consider only inside surfaces or false, to consider only outside surfaces.

Returns

The distance to the closest surface satisfying requirements or kInfinity if no such surface exists.

Implements G4VCSGface.

Definition at line 570 of file G4PolyhedraSide.cc.

{
  G4double normSign = outgoing ? -1 : +1;
  
  //
  // Try the closest phi segment first
  //
  G4int iPhi = ClosestPhiSegment( GetPhi(p) );
  
  G4ThreeVector pdotc = p - vecs[iPhi].center;
  G4double normDist = pdotc.dot(vecs[iPhi].normal);
  
  if (normSign*normDist > -0.5*kCarTolerance)
  {
    return DistanceAway( p, vecs[iPhi], &normDist );
  }
 
  //
  // Now we have an interesting problem... do we try to find the
  // closest facing side??
  //
  // Considered carefully, the answer is no. We know that if we
  // are asking for the distance out, we are supposed to be inside,
  // and vice versa.
  //
  
  return kInfinity;
}

Extent()

G4double G4PolyhedraSide::Extent ( const G4ThreeVector axis )

overridevirtual

Returns the face extent along the axis.

Parameters

[in]

axis

Unit vector defining the direction.

Returns

The largest point along the given axis of the face's extent.

Implements G4VCSGface.

Definition at line 648 of file G4PolyhedraSide.cc.

{
  if (axis.perp2() < DBL_MIN)
  {
    //
    // Special case
    //
    return axis.z() < 0 ? -cone->ZLo() : cone->ZHi();
  }
 
  G4int iPhi, i1, i2;
  G4double best;
  G4ThreeVector* list[4];
  
  //
  // Which phi segment, if any, does the axis belong to
  //
  iPhi = PhiSegment( GetPhi(axis) );
  
  if (iPhi < 0)
  {
    //
    // No phi segment? Check front edge of first side and
    // last edge of second side
    //
    i1 = 0; i2 = numSide-1;
  }
  else
  {
    //
    // Check all corners of matching phi side
    //
    i1 = iPhi; i2 = iPhi;
  }
  
  list[0] = vecs[i1].edges[0]->corner;
  list[1] = vecs[i1].edges[0]->corner+1;
  list[2] = vecs[i2].edges[1]->corner;
  list[3] = vecs[i2].edges[1]->corner+1;
        
  //
  // Who's biggest?
  //
  best = -kInfinity;
  G4ThreeVector** vec = list;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    G4double answer = (*vec)->dot(axis);
    if (answer > best) { best = answer; }
  } while( ++vec < list+4 );
  
  return best;
}

GetInstanceID()

G4int G4PolyhedraSide::GetInstanceID ( ) const

inline

Returns the instance ID.

Definition at line 220 of file G4PolyhedraSide.hh.

{ return instanceID; }

GetSubInstanceManager()

const G4PhSideManager & G4PolyhedraSide::GetSubInstanceManager ( )

static

Returns the private data instance manager.

Definition at line 56 of file G4PolyhedraSide.cc.

{
  return subInstanceManager;
}

Referenced by G4SolidsWorkspace::G4SolidsWorkspace().

Inside()

EInside G4PolyhedraSide::Inside ( const G4ThreeVector & p, G4double tolerance, G4double * bestDistance )

overridevirtual

Determines whether a point is inside, outside, or on the surface of the face.

Parameters

[in]	p	Position.
[in]	tolerance	Tolerance defining the bounds of the "kSurface", nominally equal to kCarTolerance/2.
[out]	bestDistance	Distance to the closest surface (in or out).

Returns

kInside if the point is closest to the inside surface; kOutside if the point is closest to the outside surface; kSurface if the point is withing tolerance of the surface.

Implements G4VCSGface.

Definition at line 601 of file G4PolyhedraSide.cc.

{
  //
  // Which phi segment is closest to this point?
  //
  G4int iPhi = ClosestPhiSegment( GetPhi(p) );
  
  G4double norm;
  
  //
  // Get distance to this segment
  //
  *bestDistance = DistanceToOneSide( p, vecs[iPhi], &norm );
  
  //
  // Use distance along normal to decide return value
  //
  if ( (std::fabs(norm) > tolerance) || (*bestDistance > 2.0*tolerance) )
  {
    return (norm < 0) ? kInside : kOutside;
  }
  return kSurface;
}

Intersect()

G4bool G4PolyhedraSide::Intersect ( const G4ThreeVector & p, const G4ThreeVector & v, G4bool outgoing, G4double surfTolerance, G4double & distance, G4double & distFromSurface, G4ThreeVector & normal, G4bool & allBehind )

overridevirtual

Determines the distance along a line to the face.

Parameters

[in]	p	Position.
[in]	v	Direction (assumed to be a unit vector).
[in]	outgoing	Flag true, to consider only inside surfaces; false, to consider only outside surfaces.
[in]	surfTolerance	Minimum distance from the surface.
[out]	distance	Distance to intersection.
[out]	distFromSurface	Distance from surface (along surface normal), < 0 if the point is in front of the surface.
[out]	normal	Normal of surface at intersection point.
[out]	allBehind	Flag, true, if entire surface is behind normal.

Returns

true if there is an intersection, false otherwise.

Implements G4VCSGface.

Definition at line 450 of file G4PolyhedraSide.cc.

{
  G4double normSign = outgoing ? +1 : -1;
  
  //
  // ------------------TO BE IMPLEMENTED---------------------
  // Testing the intersection of individual phi faces is
  // pretty straight forward. The simple thing therefore is to
  // form a loop and check them all in sequence.
  //
  // But, I worry about one day someone making
  // a polygon with a thousands sides. A linear search
  // would not be ideal in such a case.
  //
  // So, it would be nice to be able to quickly decide
  // which face would be intersected. One can make a very
  // good guess by using the intersection with a cone.
  // However, this is only reliable in 99% of the cases.
  //
  // My solution: make a decent guess as to the one or
  // two potential faces might get intersected, and then
  // test them. If we have the wrong face, use the test
  // to make a better guess.
  //
  // Since we might have two guesses, form a queue of
  // potential intersecting faces. Keep an array of 
  // already tested faces to avoid doing one more than
  // once.
  //
  // Result: at worst, an iterative search. On average,
  // a little more than two tests would be required.
  //
  G4ThreeVector q = p + v;
  
  G4int face = 0;
  G4PolyhedraSideVec* vec = vecs;
  do    // Loop checking, 13.08.2015, G.Cosmo
  {
    //
    // Correct normal?
    //
    G4double dotProd = normSign*v.dot(vec->normal);
    if (dotProd <= 0) { continue; }
  
    //
    // Is this face in front of the point along the trajectory?
    //
    G4ThreeVector delta = p - vec->center;
    distFromSurface = -normSign*delta.dot(vec->normal);
    
    if (distFromSurface < -surfTolerance) { continue; }
    
    //
    //                            phi
    //      c -------- d           ^
    //      |          |           |
    //      a -------- b           +---> r/z
    //
    //
    // Do we remain on this particular segment?
    //
    G4ThreeVector qc = q - vec->edges[1]->corner[0];
    G4ThreeVector qd = q - vec->edges[1]->corner[1];
    
    if (normSign*qc.cross(qd).dot(v) < 0) { continue; }
    
    G4ThreeVector qa = q - vec->edges[0]->corner[0];
    G4ThreeVector qb = q - vec->edges[0]->corner[1];
    
    if (normSign*qa.cross(qb).dot(v) > 0) { continue; }
    
    //
    // We found the one and only segment we might be intersecting.
    // Do we remain within r/z bounds?
    //
    
    if (r[0] > 1/kInfinity && normSign*qa.cross(qc).dot(v) < 0) { return false; }
    if (r[1] > 1/kInfinity && normSign*qb.cross(qd).dot(v) > 0) { return false; }
    
    //
    // We allow the face to be slightly behind the trajectory
    // (surface tolerance) only if the point p is within
    // the vicinity of the face
    //
    if (distFromSurface < 0)
    {
      G4ThreeVector ps = p - vec->center; 
      
      G4double rz = ps.dot(vec->surfRZ);
      if (std::fabs(rz) > lenRZ+surfTolerance) { return false; }
 
      G4double pp = ps.dot(vec->surfPhi);
      if (std::fabs(pp) > lenPhi[0]+lenPhi[1]*rz+surfTolerance) { return false; }
    }
      
 
    //
    // Intersection found. Return answer.
    //
    distance = distFromSurface/dotProd;
    normal = vec->normal;
    isAllBehind = allBehind;
    return true;
  } while( ++vec, ++face < numSide );
 
  //
  // Oh well. Better luck next time.
  //
  return false;
}

Normal()

G4ThreeVector G4PolyhedraSide::Normal ( const G4ThreeVector & p, G4double * bestDistance )

overridevirtual

Returns the normal of surface closest to the point.

Parameters

[in]	p	Position.
[out]	bestDistance	Distance to the closest surface (in or out).

Returns

The normal of the surface nearest the point.

Implements G4VCSGface.

Definition at line 629 of file G4PolyhedraSide.cc.

{
  //
  // Which phi segment is closest to this point?
  //
  G4int iPhi = ClosestPhiSegment( GetPhi(p) );
 
  //
  // Get distance to this segment
  //
  G4double norm;
  *bestDistance = DistanceToOneSide( p, vecs[iPhi], &norm );
 
  return vecs[iPhi].normal;
}

operator=()

G4PolyhedraSide & G4PolyhedraSide::operator=

(

const G4PolyhedraSide &

source

)

Definition at line 340 of file G4PolyhedraSide.cc.

{
  if (this == &source) { return *this; }
  
  delete cone;
  delete [] vecs;
  delete [] edges;
  
  CopyStuff( source );
 
  return *this;
}

SurfaceArea()

G4double G4PolyhedraSide::SurfaceArea ( )

overridevirtual

Returning an estimation of the face surface area, in internal units.

Implements G4VCSGface.

Definition at line 1217 of file G4PolyhedraSide.cc.

{
  if( fSurfaceArea==0. )
  { 
    // Define the variables
    //
    G4double area,areas;
    G4ThreeVector point1;
    G4ThreeVector v1,v2,v3,v4; 
    G4PolyhedraSideVec* vec = vecs;
    areas=0.;
 
    // Do a loop on all SideEdge
    //
    do    // Loop checking, 13.08.2015, G.Cosmo
    {
      // Define 4points for a Plane or Triangle
      //
      v1=vec->edges[0]->corner[0];
      v2=vec->edges[0]->corner[1];
      v3=vec->edges[1]->corner[1];
      v4=vec->edges[1]->corner[0];
      point1=GetPointOnPlane(v1,v2,v3,v4,&area);
      areas+=area;
    } while( ++vec < vecs + numSide);
 
    fSurfaceArea=areas;
  }
  return fSurfaceArea;
}

Friends And Related Symbol Documentation

sG4PolyhedraSideVec

friend struct sG4PolyhedraSideVec

friend

Definition at line 233 of file G4PolyhedraSide.hh.

Referenced by sG4PolyhedraSideVec.

---

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

• G4PolyhedraSide.hh
• G4PolyhedraSide.cc