HepPolyhedron Class Reference

#include <HepPolyhedron.h>

Inheritance diagram for HepPolyhedron:

Public Member Functions
	HepPolyhedron ()
	HepPolyhedron (G4int Nvert, G4int Nface)
	HepPolyhedron (const HepPolyhedron &from)
	HepPolyhedron (HepPolyhedron &&from)
virtual	~HepPolyhedron ()
HepPolyhedron &	operator= (const HepPolyhedron &from)
HepPolyhedron &	operator= (HepPolyhedron &&from)
G4int	GetNoVertices () const
G4int	GetNoVerteces () const
G4int	GetNoFacets () const
HepPolyhedron &	Transform (const G4Transform3D &t)
G4bool	GetNextVertexIndex (G4int &index, G4int &edgeFlag) const
G4Point3D	GetVertex (G4int index) const
G4bool	GetNextVertex (G4Point3D &vertex, G4int &edgeFlag) const
G4bool	GetNextVertex (G4Point3D &vertex, G4int &edgeFlag, G4Normal3D &normal) const
G4bool	GetNextEdgeIndices (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
G4bool	GetNextEdgeIndices (G4int &i1, G4int &i2, G4int &edgeFlag) const
G4bool	GetNextEdgeIndeces (G4int &i1, G4int &i2, G4int &edgeFlag) const
G4bool	GetNextEdge (G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag) const
G4bool	GetNextEdge (G4Point3D &p1, G4Point3D &p2, G4int &edgeFlag, G4int &iface1, G4int &iface2) const
void	GetFacet (G4int iFace, G4int &n, G4int *iNodes, G4int *edgeFlags=nullptr, G4int *iFaces=nullptr) const
void	GetFacet (G4int iFace, G4int &n, G4Point3D *nodes, G4int *edgeFlags=nullptr, G4Normal3D *normals=nullptr) const
G4bool	GetNextFacet (G4int &n, G4Point3D *nodes, G4int *edgeFlags=nullptr, G4Normal3D *normals=nullptr) const
G4Normal3D	GetNormal (G4int iFace) const
G4Normal3D	GetUnitNormal (G4int iFace) const
G4bool	GetNextNormal (G4Normal3D &normal) const
G4bool	GetNextUnitNormal (G4Normal3D &normal) const
HepPolyhedron	add (const HepPolyhedron &p) const
HepPolyhedron	subtract (const HepPolyhedron &p) const
HepPolyhedron	intersect (const HepPolyhedron &p) const
G4double	GetSurfaceArea () const
G4double	GetVolume () const
void	SetVertex (G4int index, const G4Point3D &v)
void	SetFacet (G4int index, G4int iv1, G4int iv2, G4int iv3, G4int iv4=0)
void	SetReferences ()
void	JoinCoplanarFacets (G4double tolerance)
void	InvertFacets ()
G4int	createTwistedTrap (G4double Dz, const G4double xy1[][2], const G4double xy2[][2])
G4int	createPolyhedron (G4int Nnodes, G4int Nfaces, const G4double xyz[][3], const G4int faces[][4])
G4Point3D	vertexUnweightedMean () const

Static Public Member Functions
static G4int	GetNumberOfRotationSteps ()
static void	SetNumberOfRotationSteps (G4int n)
static void	ResetNumberOfRotationSteps ()

Protected Member Functions
void	AllocateMemory (G4int Nvert, G4int Nface)
G4int	FindNeighbour (G4int iFace, G4int iNode, G4int iOrder) const
G4Normal3D	FindNodeNormal (G4int iFace, G4int iNode) const
void	CreatePrism ()
void	RotateEdge (G4int k1, G4int k2, G4double r1, G4double r2, G4int v1, G4int v2, G4int vEdge, G4bool ifWholeCircle, G4int ns, G4int &kface)
void	SetSideFacets (G4int ii[4], G4int vv[4], G4int *kk, G4double *r, G4double dphi, G4int ns, G4int &kface)
void	RotateAroundZ (G4int nstep, G4double phi, G4double dphi, G4int np1, G4int np2, const G4double *z, G4double *r, G4int nodeVis, G4int edgeVis)
void	RotateContourAroundZ (G4int nstep, G4double phi, G4double dphi, const std::vector< G4TwoVector > &rz, G4int nodeVis, G4int edgeVis)
G4bool	TriangulatePolygon (const std::vector< G4TwoVector > &polygon, std::vector< G4int > &result)
G4bool	CheckSnip (const std::vector< G4TwoVector > &contour, G4int a, G4int b, G4int c, G4int n, const G4int *V)

Protected Attributes
G4int	nvert
G4int	nface
G4Point3D *	pV
G4Facet *	pF

Static Protected Attributes
static G4ThreadLocal G4int	fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

Friends
std::ostream &	operator<< (std::ostream &ostr, const HepPolyhedron &ph)

Detailed Description

Definition at line 231 of file HepPolyhedron.h.

Constructor & Destructor Documentation

HepPolyhedron() [1/4]

HepPolyhedron::HepPolyhedron ( )

inline

Definition at line 284 of file HepPolyhedron.h.

: nvert(0), nface(0), pV(nullptr), pF(nullptr) {}

HepPolyhedron() [2/4]

HepPolyhedron::HepPolyhedron	(	G4int	Nvert,
		G4int	Nface )

Definition at line 120 of file HepPolyhedron.cc.

: nvert(0), nface(0), pV(nullptr), pF(nullptr)
{
  AllocateMemory(Nvert, Nface);
}

HepPolyhedron() [3/4]

HepPolyhedron::HepPolyhedron

(

const HepPolyhedron &

from

)

Definition at line 133 of file HepPolyhedron.cc.

: nvert(0), nface(0), pV(nullptr), pF(nullptr)
{
  AllocateMemory(from.nvert, from.nface);
  for (G4int i=1; i<=nvert; i++) pV[i] = from.pV[i];
  for (G4int k=1; k<=nface; k++) pF[k] = from.pF[k];
}

HepPolyhedron() [4/4]

HepPolyhedron::HepPolyhedron

(

HepPolyhedron &&

from

)

Definition at line 147 of file HepPolyhedron.cc.

: nvert(0), nface(0), pV(nullptr), pF(nullptr)
{
  nvert = from.nvert;
  nface = from.nface;
  pV = from.pV;
  pF = from.pF;
 
  // Release the data from the source object
  from.nvert = 0;
  from.nface = 0;
  from.pV = nullptr;
  from.pF = nullptr;
}

~HepPolyhedron()

virtual HepPolyhedron::~HepPolyhedron ( )

inlinevirtual

Definition at line 296 of file HepPolyhedron.h.

{ delete [] pV; delete [] pF; }

Member Function Documentation

add()

HepPolyhedron HepPolyhedron::add

(

const HepPolyhedron &

p

)

const

Definition at line 3361 of file HepPolyhedron.cc.

{
  G4int ierr;
  BooleanProcessor processor;
  return processor.execute(OP_UNION, *this, p,ierr);
}

AllocateMemory()

void HepPolyhedron::AllocateMemory ( G4int Nvert, G4int Nface )

protected

Definition at line 374 of file HepPolyhedron.cc.

{
  if (nvert == Nvert && nface == Nface) return;
  delete [] pV;
  delete [] pF;
  if (Nvert > 0 && Nface > 0) {
    nvert = Nvert;
    nface = Nface;
    pV    = new G4Point3D[nvert+1];
    pF    = new G4Facet[nface+1];
  }else{
    nvert = 0; nface = 0; pV = nullptr; pF = nullptr;
  }
}

Referenced by createPolyhedron(), createTwistedTrap(), G4PolyhedronArbitrary::G4PolyhedronArbitrary(), HepPolyhedron(), HepPolyhedron(), HepPolyhedronBoxMesh::HepPolyhedronBoxMesh(), HepPolyhedronTet::HepPolyhedronTet(), HepPolyhedronTetMesh::HepPolyhedronTetMesh(), HepPolyhedronTrap::HepPolyhedronTrap(), HepPolyhedronTrd2::HepPolyhedronTrd2(), operator=(), RotateAroundZ(), and RotateContourAroundZ().

CheckSnip()

G4bool HepPolyhedron::CheckSnip ( const std::vector< G4TwoVector > & contour, G4int a, G4int b, G4int c, G4int n, const G4int * V )

protected

Definition at line 1063 of file HepPolyhedron.cc.

{
  static const G4double kCarTolerance = 1.e-9;
 
  // check orientation of Triangle
  G4double Ax = contour[V[a]].x(), Ay = contour[V[a]].y();
  G4double Bx = contour[V[b]].x(), By = contour[V[b]].y();
  G4double Cx = contour[V[c]].x(), Cy = contour[V[c]].y();
  if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) < kCarTolerance) return false;
 
  // check that there is no point inside Triangle
  G4double xmin = std::min(std::min(Ax,Bx),Cx);
  G4double xmax = std::max(std::max(Ax,Bx),Cx);
  G4double ymin = std::min(std::min(Ay,By),Cy);
  G4double ymax = std::max(std::max(Ay,By),Cy);
 
  for (G4int i=0; i<n; ++i)
  {
    if((i == a) || (i == b) || (i == c)) continue;
    G4double Px = contour[V[i]].x();
    if (Px < xmin || Px > xmax) continue;
    G4double Py = contour[V[i]].y();
    if (Py < ymin || Py > ymax) continue;
    // if (PointInTriangle(Ax,Ay,Bx,By,Cx,Cy,Px,Py)) return false;
    if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) > 0.)
    {
      if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) < 0.) continue;
      if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) < 0.) continue;
      if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) < 0.) continue;
    }
    else
    {
      if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) > 0.) continue;
      if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) > 0.) continue;
      if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) > 0.) continue;
    }
    return false;
  }
  return true;
}

Referenced by TriangulatePolygon().

createPolyhedron()

G4int HepPolyhedron::createPolyhedron	(	G4int	Nnodes,
		G4int	Nfaces,
		const G4double	xyz[][3],
		const G4int	faces[][4] )

Creates user defined polyhedron. This function allows to the user to define arbitrary polyhedron. The faces of the polyhedron should be either triangles or planar quadrilateral. Nodes of a face are defined by indexes pointing to the elements in the xyz array. Numeration of the elements in the array starts from 1 (like in fortran). The indexes can be positive or negative. Negative sign means that the corresponding edge is invisible. The normal of the face should be directed to exterior of the polyhedron.

Parameters

Nnodes	number of nodes
Nfaces	number of faces
xyz	nodes
faces	faces (quadrilaterals or triangles)

Returns

status of the operation - is non-zero in case of problem

Definition at line 1902 of file HepPolyhedron.cc.

{
  AllocateMemory(Nnodes, Nfaces);
  if (nvert == 0) return 1;
 
  for (G4int i=0; i<Nnodes; i++) {
    pV[i+1] = G4Point3D(xyz[i][0], xyz[i][1], xyz[i][2]);
  }
  for (G4int k=0; k<Nfaces; k++) {
    pF[k+1] = G4Facet(faces[k][0],0,faces[k][1],0,faces[k][2],0,faces[k][3],0);
  }
  SetReferences();
  return 0;
}

Referenced by G4Tet::CreatePolyhedron().

CreatePrism()

void HepPolyhedron::CreatePrism ( )

protected

Definition at line 400 of file HepPolyhedron.cc.

{
  enum {DUMMY, BOTTOM, LEFT, BACK, RIGHT, FRONT, TOP};
 
  pF[1] = G4Facet(1,LEFT,  4,BACK,  3,RIGHT,  2,FRONT);
  pF[2] = G4Facet(5,TOP,   8,BACK,  4,BOTTOM, 1,FRONT);
  pF[3] = G4Facet(8,TOP,   7,RIGHT, 3,BOTTOM, 4,LEFT);
  pF[4] = G4Facet(7,TOP,   6,FRONT, 2,BOTTOM, 3,BACK);
  pF[5] = G4Facet(6,TOP,   5,LEFT,  1,BOTTOM, 2,RIGHT);
  pF[6] = G4Facet(5,FRONT, 6,RIGHT, 7,BACK,   8,LEFT);
}

Referenced by HepPolyhedronTrap::HepPolyhedronTrap(), and HepPolyhedronTrd2::HepPolyhedronTrd2().

createTwistedTrap()

G4int HepPolyhedron::createTwistedTrap	(	G4double	Dz,
		const G4double	xy1[][2],
		const G4double	xy2[][2] )

Creates polyhedron for twisted trapezoid. The trapezoid is given by two bases perpendicular to the z-axis.

Parameters

Dz	half length in z
xy1	1st base (at z = -Dz)
xy2	2nd base (at z = +Dz)

Returns

status of the operation - is non-zero in case of problem

Definition at line 1833 of file HepPolyhedron.cc.

{
  AllocateMemory(12,18);
 
  pV[ 1] = G4Point3D(xy1[0][0],xy1[0][1],-Dz);
  pV[ 2] = G4Point3D(xy1[1][0],xy1[1][1],-Dz);
  pV[ 3] = G4Point3D(xy1[2][0],xy1[2][1],-Dz);
  pV[ 4] = G4Point3D(xy1[3][0],xy1[3][1],-Dz);
 
  pV[ 5] = G4Point3D(xy2[0][0],xy2[0][1], Dz);
  pV[ 6] = G4Point3D(xy2[1][0],xy2[1][1], Dz);
  pV[ 7] = G4Point3D(xy2[2][0],xy2[2][1], Dz);
  pV[ 8] = G4Point3D(xy2[3][0],xy2[3][1], Dz);
 
  pV[ 9] = (pV[1]+pV[2]+pV[5]+pV[6])/4.;
  pV[10] = (pV[2]+pV[3]+pV[6]+pV[7])/4.;
  pV[11] = (pV[3]+pV[4]+pV[7]+pV[8])/4.;
  pV[12] = (pV[4]+pV[1]+pV[8]+pV[5])/4.;
 
  enum {DUMMY, BOTTOM,
        LEFT_BOTTOM,  LEFT_FRONT,   LEFT_TOP,  LEFT_BACK,
        BACK_BOTTOM,  BACK_LEFT,    BACK_TOP,  BACK_RIGHT,
        RIGHT_BOTTOM, RIGHT_BACK,   RIGHT_TOP, RIGHT_FRONT,
        FRONT_BOTTOM, FRONT_RIGHT,  FRONT_TOP, FRONT_LEFT,
        TOP};
 
  pF[ 1]=G4Facet(1,LEFT_BOTTOM, 4,BACK_BOTTOM, 3,RIGHT_BOTTOM, 2,FRONT_BOTTOM);
 
  pF[ 2]=G4Facet(4,BOTTOM,     -1,LEFT_FRONT,  -12,LEFT_BACK,    0,0);
  pF[ 3]=G4Facet(1,FRONT_LEFT, -5,LEFT_TOP,    -12,LEFT_BOTTOM,  0,0);
  pF[ 4]=G4Facet(5,TOP,        -8,LEFT_BACK,   -12,LEFT_FRONT,   0,0);
  pF[ 5]=G4Facet(8,BACK_LEFT,  -4,LEFT_BOTTOM, -12,LEFT_TOP,     0,0);
 
  pF[ 6]=G4Facet(3,BOTTOM,     -4,BACK_LEFT,   -11,BACK_RIGHT,   0,0);
  pF[ 7]=G4Facet(4,LEFT_BACK,  -8,BACK_TOP,    -11,BACK_BOTTOM,  0,0);
  pF[ 8]=G4Facet(8,TOP,        -7,BACK_RIGHT,  -11,BACK_LEFT,    0,0);
  pF[ 9]=G4Facet(7,RIGHT_BACK, -3,BACK_BOTTOM, -11,BACK_TOP,     0,0);
 
  pF[10]=G4Facet(2,BOTTOM,     -3,RIGHT_BACK,  -10,RIGHT_FRONT,  0,0);
  pF[11]=G4Facet(3,BACK_RIGHT, -7,RIGHT_TOP,   -10,RIGHT_BOTTOM, 0,0);
  pF[12]=G4Facet(7,TOP,        -6,RIGHT_FRONT, -10,RIGHT_BACK,   0,0);
  pF[13]=G4Facet(6,FRONT_RIGHT,-2,RIGHT_BOTTOM,-10,RIGHT_TOP,    0,0);
 
  pF[14]=G4Facet(1,BOTTOM,     -2,FRONT_RIGHT,  -9,FRONT_LEFT,   0,0);
  pF[15]=G4Facet(2,RIGHT_FRONT,-6,FRONT_TOP,    -9,FRONT_BOTTOM, 0,0);
  pF[16]=G4Facet(6,TOP,        -5,FRONT_LEFT,   -9,FRONT_RIGHT,  0,0);
  pF[17]=G4Facet(5,LEFT_FRONT, -1,FRONT_BOTTOM, -9,FRONT_TOP,    0,0);
 
  pF[18]=G4Facet(5,FRONT_TOP, 6,RIGHT_TOP, 7,BACK_TOP, 8,LEFT_TOP);
 
  return 0;
}

FindNeighbour()

G4int HepPolyhedron::FindNeighbour ( G4int iFace, G4int iNode, G4int iOrder ) const

protected

Definition at line 214 of file HepPolyhedron.cc.

{
  G4int i;
  for (i=0; i<4; i++) {
    if (iNode == std::abs(pF[iFace].edge[i].v)) break;
  }
  if (i == 4) {
    std::cerr
      << "HepPolyhedron::FindNeighbour: face " << iFace
      << " has no node " << iNode
      << std::endl;
    return 0;
  }
  if (iOrder < 0) {
    if ( --i < 0) i = 3;
    if (pF[iFace].edge[i].v == 0) i = 2;
  }
  return (pF[iFace].edge[i].v > 0) ? 0 : pF[iFace].edge[i].f;
}

FindNodeNormal()

G4Normal3D HepPolyhedron::FindNodeNormal ( G4int iFace, G4int iNode ) const

protected

Definition at line 242 of file HepPolyhedron.cc.

{
  G4Normal3D normal = GetUnitNormal(iFace);
  G4int      k = iFace, iOrder = 1;
 
  for(;;) {
    k = FindNeighbour(k, iNode, iOrder);
    if (k == iFace) break;
    if (k > 0) {
      normal += GetUnitNormal(k);
    }else{
      if (iOrder < 0) break;
      k = iFace;
      iOrder = -iOrder;
    }
  }
  return normal.unit();
}

GetFacet() [1/2]

void HepPolyhedron::GetFacet	(	G4int	iFace,
		G4int &	n,
		G4int *	iNodes,
		G4int *	edgeFlags = nullptr,
		G4int *	iFaces = nullptr ) const

Definition at line 1610 of file HepPolyhedron.cc.

{
  if (iFace < 1 || iFace > nface) {
    std::cerr
      << "HepPolyhedron::GetFacet: irrelevant index " << iFace
      << std::endl;
    n = 0;
  }else{
    G4int i, k;
    for (i=0; i<4; i++) {
      k = pF[iFace].edge[i].v;
      if (k == 0) break;
      if (iFaces != nullptr) iFaces[i] = pF[iFace].edge[i].f;
      if (k > 0) {
        iNodes[i] = k;
        if (edgeFlags != nullptr) edgeFlags[i] = 1;
      }else{
        iNodes[i] = -k;
        if (edgeFlags != nullptr) edgeFlags[i] = -1;
      }
    }
    n = i;
  }
}

Referenced by G4CutTubs::CreatePolyhedron().

GetFacet() [2/2]

void HepPolyhedron::GetFacet	(	G4int	iFace,
		G4int &	n,
		G4Point3D *	nodes,
		G4int *	edgeFlags = nullptr,
		G4Normal3D *	normals = nullptr ) const

Definition at line 1644 of file HepPolyhedron.cc.

{
  G4int iNodes[4];
  GetFacet(index, n, iNodes, edgeFlags);
  if (n != 0) {
    for (G4int i=0; i<n; i++) {
      nodes[i] = pV[iNodes[i]];
      if (normals != nullptr) normals[i] = FindNodeNormal(index,iNodes[i]);
    }
  }
}

GetNextEdge() [1/2]

G4bool HepPolyhedron::GetNextEdge	(	G4Point3D &	p1,
		G4Point3D &	p2,
		G4int &	edgeFlag ) const

Definition at line 1569 of file HepPolyhedron.cc.

{
  G4int i1,i2;
  G4bool rep = GetNextEdgeIndices(i1,i2,edgeFlag);
  p1 = pV[i1];
  p2 = pV[i2];
  return rep;
}

Referenced by G4GMocrenFileSceneHandler::AddSolid().

GetNextEdge() [2/2]

G4bool HepPolyhedron::GetNextEdge	(	G4Point3D &	p1,
		G4Point3D &	p2,
		G4int &	edgeFlag,
		G4int &	iface1,
		G4int &	iface2 ) const

Definition at line 1590 of file HepPolyhedron.cc.

{
  G4int i1,i2;
  G4bool rep = GetNextEdgeIndices(i1,i2,edgeFlag,iface1,iface2);
  p1 = pV[i1];
  p2 = pV[i2];
  return rep;
}

GetNextEdgeIndeces() [1/2]

G4bool HepPolyhedron::GetNextEdgeIndeces ( G4int & i1, G4int & i2, G4int & edgeFlag ) const

inline

Definition at line 336 of file HepPolyhedron.h.

  {return GetNextEdgeIndices(i1,i2,edgeFlag);}  // Old spelling.

GetNextEdgeIndeces() [2/2]

G4bool HepPolyhedron::GetNextEdgeIndeces ( G4int & i1, G4int & i2, G4int & edgeFlag, G4int & iface1, G4int & iface2 ) const

inline

Definition at line 330 of file HepPolyhedron.h.

  {return GetNextEdgeIndices(i1,i2,edgeFlag,iface1,iface2);}  // Old spelling

GetNextEdgeIndices() [1/2]

G4bool HepPolyhedron::GetNextEdgeIndices	(	G4int &	i1,
		G4int &	i2,
		G4int &	edgeFlag ) const

Definition at line 1553 of file HepPolyhedron.cc.

{
  G4int kface1, kface2;
  return GetNextEdgeIndices(i1, i2, edgeFlag, kface1, kface2);
}

GetNextEdgeIndices() [2/2]

G4bool HepPolyhedron::GetNextEdgeIndices	(	G4int &	i1,
		G4int &	i2,
		G4int &	edgeFlag,
		G4int &	iface1,
		G4int &	iface2 ) const

Definition at line 1500 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace    = 1;
  static G4ThreadLocal G4int iQVertex = 0;
  static G4ThreadLocal G4int iOrder   = 1;
  G4int  k1, k2, kflag, kface1, kface2;
 
  if (iFace == 1 && iQVertex == 0) {
    k2 = pF[nface].edge[0].v;
    k1 = pF[nface].edge[3].v;
    if (k1 == 0) k1 = pF[nface].edge[2].v;
    if (std::abs(k1) > std::abs(k2)) iOrder = -1;
  }
 
  do {
    k1     = pF[iFace].edge[iQVertex].v;
    kflag  = k1;
    k1     = std::abs(k1);
    kface1 = iFace;
    kface2 = pF[iFace].edge[iQVertex].f;
    if (iQVertex >= 3 || pF[iFace].edge[iQVertex+1].v == 0) {
      iQVertex = 0;
      k2 = std::abs(pF[iFace].edge[iQVertex].v);
      iFace++;
    }else{
      iQVertex++;
      k2 = std::abs(pF[iFace].edge[iQVertex].v);
    }
  } while (iOrder*k1 > iOrder*k2);
 
  i1 = k1; i2 = k2; edgeFlag = (kflag > 0) ? 1 : 0;
  iface1 = kface1; iface2 = kface2;
 
  if (iFace > nface) {
    iFace  = 1; iOrder = 1;
    return false;
  }
 
  return true;
}

Referenced by GetNextEdgeIndeces(), and GetNextEdgeIndeces().

GetNextFacet()

G4bool HepPolyhedron::GetNextFacet	(	G4int &	n,
		G4Point3D *	nodes,
		G4int *	edgeFlags = nullptr,
		G4Normal3D *	normals = nullptr ) const

Definition at line 1666 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
 
  if (edgeFlags == nullptr) {
    GetFacet(iFace, n, nodes);
  }else if (normals == nullptr) {
    GetFacet(iFace, n, nodes, edgeFlags);
  }else{
    GetFacet(iFace, n, nodes, edgeFlags, normals);
  }
 
  if (++iFace > nface) {
    iFace  = 1;
    return false;
  }
 
  return true;
}

Referenced by G4VtkPolydataInstanceBakePipeline::addInstance(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), std::hash< G4Polyhedron >::operator()(), and G4VtkPolydataPipeline::SetPolydata().

GetNextNormal()

G4bool HepPolyhedron::GetNextNormal

(

G4Normal3D &

normal

)

const

Definition at line 1746 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
  normal = GetNormal(iFace);
  if (++iFace > nface) {
    iFace = 1;
    return false;
  }
  return true;
}

Referenced by G4HepRepFileSceneHandler::AddPrimitive().

GetNextUnitNormal()

G4bool HepPolyhedron::GetNextUnitNormal

(

G4Normal3D &

normal

)

const

Definition at line 1766 of file HepPolyhedron.cc.

{
  G4bool rep = GetNextNormal(normal);
  normal = normal.unit();
  return rep;
}

Referenced by Geant4_SoPolyhedron::computeBBox(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNextVertex() [1/2]

G4bool HepPolyhedron::GetNextVertex	(	G4Point3D &	vertex,
		G4int &	edgeFlag ) const

Definition at line 1451 of file HepPolyhedron.cc.

{
  G4int index;
  G4bool rep = GetNextVertexIndex(index, edgeFlag);
  vertex = pV[index];
  return rep;
}

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), Geant4_SoPolyhedron::computeBBox(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNextVertex() [2/2]

G4bool HepPolyhedron::GetNextVertex	(	G4Point3D &	vertex,
		G4int &	edgeFlag,
		G4Normal3D &	normal ) const

Definition at line 1469 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
  static G4ThreadLocal G4int iNode = 0;
 
  if (nface == 0) return false;  // empty polyhedron
 
  G4int k = pF[iFace].edge[iNode].v;
  if (k > 0) { edgeFlag = 1; } else { edgeFlag = -1; k = -k; }
  vertex = pV[k];
  normal = FindNodeNormal(iFace,k);
  if (iNode >= 3 || pF[iFace].edge[iNode+1].v == 0) {
    iNode = 0;
    if (++iFace > nface) iFace = 1;
    return false;                // last node
  }
  ++iNode;
  return true;                 // not last node
}

GetNextVertexIndex()

G4bool HepPolyhedron::GetNextVertexIndex	(	G4int &	index,
		G4int &	edgeFlag ) const

Definition at line 1404 of file HepPolyhedron.cc.

{
  static G4ThreadLocal G4int iFace = 1;
  static G4ThreadLocal G4int iQVertex = 0;
  G4int vIndex = pF[iFace].edge[iQVertex].v;
 
  edgeFlag = (vIndex > 0) ? 1 : 0;
  index = std::abs(vIndex);
 
  if (iQVertex >= 3 || pF[iFace].edge[iQVertex+1].v == 0) {
    iQVertex = 0;
    if (++iFace > nface) iFace = 1;
    return false;  // Last Edge
  }
  
  ++iQVertex;
  return true;  // not Last Edge
}

Referenced by G4GMocrenFileSceneHandler::AddPrimitive().

GetNoFacets()

G4int HepPolyhedron::GetNoFacets ( ) const

inline

Definition at line 309 of file HepPolyhedron.h.

{ return nface; }

Referenced by G4GMocrenFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkStore::AddPrimitiveAppend(), G4VtkStore::AddPrimitiveSeparate(), G4VtkStore::AddPrimitiveTensorGlyph(), G4VtkStore::AddPrimitiveTransformBake(), Geant4_SoPolyhedron::computeBBox(), G4CutTubs::CreatePolyhedron(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNormal()

G4Normal3D HepPolyhedron::GetNormal

(

G4int

iFace

)

const

Definition at line 1696 of file HepPolyhedron.cc.

{
  if (iFace < 1 || iFace > nface) {
    std::cerr
      << "HepPolyhedron::GetNormal: irrelevant index " << iFace
      << std::endl;
    return G4Normal3D();
  }
 
  G4int i0  = std::abs(pF[iFace].edge[0].v);
  G4int i1  = std::abs(pF[iFace].edge[1].v);
  G4int i2  = std::abs(pF[iFace].edge[2].v);
  G4int i3  = std::abs(pF[iFace].edge[3].v);
  if (i3 == 0) i3 = i0;
  return (pV[i2] - pV[i0]).cross(pV[i3] - pV[i1]);
}

GetNoVerteces()

G4int HepPolyhedron::GetNoVerteces ( ) const

inline

Definition at line 306 of file HepPolyhedron.h.

{ return nvert; }  // Old spelling.

GetNoVertices()

G4int HepPolyhedron::GetNoVertices ( ) const

inline

Definition at line 305 of file HepPolyhedron.h.

{ return nvert; }

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4CutTubs::CreatePolyhedron(), and Geant4_SoPolyhedron::generateAlternateRep().

GetNumberOfRotationSteps()

G4int HepPolyhedron::GetNumberOfRotationSteps ( )

static

Definition at line 269 of file HepPolyhedron.cc.

{
  return fNumberOfRotationSteps;
}

Referenced by G4TwistedTubs::CreatePolyhedron(), G4VTwistedFaceted::CreatePolyhedron(), G4ArrowModel::G4ArrowModel(), G4ViewParameters::G4ViewParameters(), G4BooleanSolid::GetPolyhedron(), G4CSGSolid::GetPolyhedron(), G4DisplacedSolid::GetPolyhedron(), G4Ellipsoid::GetPolyhedron(), G4EllipticalCone::GetPolyhedron(), G4EllipticalTube::GetPolyhedron(), G4GenericTrap::GetPolyhedron(), G4Hype::GetPolyhedron(), G4MultiUnion::GetPolyhedron(), G4Paraboloid::GetPolyhedron(), G4ReflectedSolid::GetPolyhedron(), G4ScaledSolid::GetPolyhedron(), G4TessellatedSolid::GetPolyhedron(), G4Tet::GetPolyhedron(), G4TwistedTubs::GetPolyhedron(), G4VCSGfaceted::GetPolyhedron(), G4VTwistedFaceted::GetPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronSphere::HepPolyhedronSphere(), HepPolyhedronTorus::HepPolyhedronTorus(), RotateAroundZ(), and RotateContourAroundZ().

GetSurfaceArea()

G4double HepPolyhedron::GetSurfaceArea

(

)

const

Definition at line 1782 of file HepPolyhedron.cc.

{
  G4double srf = 0.;
  for (G4int iFace=1; iFace<=nface; iFace++) {
    G4int i0 = std::abs(pF[iFace].edge[0].v);
    G4int i1 = std::abs(pF[iFace].edge[1].v);
    G4int i2 = std::abs(pF[iFace].edge[2].v);
    G4int i3 = std::abs(pF[iFace].edge[3].v);
    if (i3 == 0) i3 = i0;
    srf += ((pV[i2] - pV[i0]).cross(pV[i3] - pV[i1])).mag();
  }
  return srf/2.;
}

GetUnitNormal()

G4Normal3D HepPolyhedron::GetUnitNormal

(

G4int

iFace

)

const

Definition at line 1721 of file HepPolyhedron.cc.

{
  if (iFace < 1 || iFace > nface) {
    std::cerr
      << "HepPolyhedron::GetUnitNormal: irrelevant index " << iFace
      << std::endl;
    return G4Normal3D();
  }
 
  G4int i0  = std::abs(pF[iFace].edge[0].v);
  G4int i1  = std::abs(pF[iFace].edge[1].v);
  G4int i2  = std::abs(pF[iFace].edge[2].v);
  G4int i3  = std::abs(pF[iFace].edge[3].v);
  if (i3 == 0) i3 = i0;
  return ((pV[i2] - pV[i0]).cross(pV[i3] - pV[i1])).unit();
}

Referenced by JoinCoplanarFacets().

GetVertex()

G4Point3D HepPolyhedron::GetVertex

(

G4int

index

)

const

Definition at line 1431 of file HepPolyhedron.cc.

{
  if (index <= 0 || index > nvert) {
    std::cerr
      << "HepPolyhedron::GetVertex: irrelevant index " << index
      << std::endl;
    return G4Point3D();
  }
  return pV[index];
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), and G4CutTubs::CreatePolyhedron().

GetVolume()

G4double HepPolyhedron::GetVolume

(

)

const

Definition at line 1804 of file HepPolyhedron.cc.

{
  G4double v = 0.;
  for (G4int iFace=1; iFace<=nface; iFace++) {
    G4int i0 = std::abs(pF[iFace].edge[0].v);
    G4int i1 = std::abs(pF[iFace].edge[1].v);
    G4int i2 = std::abs(pF[iFace].edge[2].v);
    G4int i3 = std::abs(pF[iFace].edge[3].v);
    G4Point3D pt;
    if (i3 == 0) {
      i3 = i0;
      pt = (pV[i0]+pV[i1]+pV[i2]) * (1./3.);
    }else{
      pt = (pV[i0]+pV[i1]+pV[i2]+pV[i3]) * 0.25;
    }
    v += ((pV[i2] - pV[i0]).cross(pV[i3] - pV[i1])).dot(pt);
  }
  return v/6.;
}

intersect()

HepPolyhedron HepPolyhedron::intersect

(

const HepPolyhedron &

p

)

const

Definition at line 3376 of file HepPolyhedron.cc.

{
  G4int ierr;
  BooleanProcessor processor;
  return processor.execute(OP_INTERSECTION, *this, p,ierr);
}

InvertFacets()

void HepPolyhedron::InvertFacets

(

)

Definition at line 1353 of file HepPolyhedron.cc.

{
  if (nface <= 0) return;
  G4int i, k, nnode, v[4],f[4];
  for (i=1; i<=nface; i++) {
    nnode =  (pF[i].edge[3].v == 0) ? 3 : 4;
    for (k=0; k<nnode; k++) {
      v[k] = (k+1 == nnode) ? pF[i].edge[0].v : pF[i].edge[k+1].v;
      if (v[k] * pF[i].edge[k].v < 0) v[k] = -v[k];
      f[k] = pF[i].edge[k].f;
    }
    for (k=0; k<nnode; k++) {
      pF[i].edge[nnode-1-k].v = v[k];
      pF[i].edge[nnode-1-k].f = f[k];
    }
  }
}

Referenced by G4GenericTrap::CreatePolyhedron(), G4PolyhedronArbitrary::InvertFacets(), and Transform().

JoinCoplanarFacets()

void HepPolyhedron::JoinCoplanarFacets

(

G4double

tolerance

)

Definition at line 1264 of file HepPolyhedron.cc.

{
  G4int njoin = 0;
  for (G4int icur = 1; icur <= nface; ++icur)
  {
    // skip if already joined or quadrangle
    if (pF[icur].edge[0].v == 0) continue;
    if (pF[icur].edge[3].v != 0) continue;
    // skip if all references point to already checked facets
    if (pF[icur].edge[0].f < icur &&
        pF[icur].edge[1].f < icur &&
        pF[icur].edge[2].f < icur) continue;
    // compute plane equation
    G4Normal3D norm = GetUnitNormal(icur);
    G4double dd = norm.dot(pV[pF[icur].edge[0].v]);
    G4int vcur0 = std::abs(pF[icur].edge[0].v);
    G4int vcur1 = std::abs(pF[icur].edge[1].v);
    G4int vcur2 = std::abs(pF[icur].edge[2].v);
    // select neighbouring facet
    G4int kcheck = 0, icheck = 0, vcheck = 0;
    G4double dist = DBL_MAX;
    for (G4int k = 0; k < 3; ++k)
    {
      G4int itmp = pF[icur].edge[k].f;
      // skip if already checked, joined or quadrangle
      if (itmp < icur) continue;
      if (pF[itmp].edge[0].v == 0 ||
          pF[itmp].edge[3].v != 0) continue;
      // get candidate vertex
      G4int vtmp = 0;
      for (G4int j = 0; j < 3; ++j)
      {
        vtmp = std::abs(pF[itmp].edge[j].v);
    if (vtmp != vcur0 && vtmp != vcur1 && vtmp != vcur2) break;
      }
      // check distance to the plane
      G4double dtmp = std::abs(norm.dot(pV[vtmp]) - dd);
      if (dtmp > tolerance || dtmp >= dist) continue;
      dist = dtmp;
      kcheck = k;
      icheck = itmp;
      vcheck = vtmp;
    }
    if (icheck == 0) continue; // no facet selected
    // join facets
    njoin++;
    pF[icheck].edge[0].v = 0; // mark facet as joined
    if (kcheck == 0)
    {
      pF[icur].edge[3].v = pF[icur].edge[2].v;
      pF[icur].edge[2].v = pF[icur].edge[1].v;
      pF[icur].edge[1].v = vcheck;
    }
    else if (kcheck == 1)
    {
      pF[icur].edge[3].v = pF[icur].edge[2].v;
      pF[icur].edge[2].v = vcheck;
    }
    else
    {
      pF[icur].edge[3].v = vcheck;
    }
  }
  if (njoin == 0) return; // no joined facets
 
  // restructure facets
  G4int nnew = 0;
  for (G4int icur = 1; icur <= nface; ++icur)
  {
    if (pF[icur].edge[0].v == 0) continue;
    nnew++;
    pF[nnew].edge[0].v = pF[icur].edge[0].v;
    pF[nnew].edge[1].v = pF[icur].edge[1].v;
    pF[nnew].edge[2].v = pF[icur].edge[2].v;
    pF[nnew].edge[3].v = pF[icur].edge[3].v;
  }
  nface = nnew;
  SetReferences();
}

operator=() [1/2]

HepPolyhedron & HepPolyhedron::operator=

(

const HepPolyhedron &

from

)

Definition at line 168 of file HepPolyhedron.cc.

{
  if (this != &from) {
    AllocateMemory(from.nvert, from.nface);
    for (G4int i=1; i<=nvert; i++) pV[i] = from.pV[i];
    for (G4int k=1; k<=nface; k++) pF[k] = from.pF[k];
  }
  return *this;
}

operator=() [2/2]

HepPolyhedron & HepPolyhedron::operator=

(

HepPolyhedron &&

from

)

Definition at line 186 of file HepPolyhedron.cc.

{
  if (this != &from) {
    delete [] pV;
    delete [] pF;
    nvert = from.nvert;
    nface = from.nface;
    pV = from.pV;
    pF = from.pF;
 
    // Release the data from the source object
    from.nvert = 0;
    from.nface = 0;
    from.pV = nullptr;
    from.pF = nullptr;
  }
  return *this;
}

ResetNumberOfRotationSteps()

void HepPolyhedron::ResetNumberOfRotationSteps ( )

static

Definition at line 361 of file HepPolyhedron.cc.

{
  fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS;
}

Referenced by G4VSceneHandler::RequestPrimitives().

RotateAroundZ()

void HepPolyhedron::RotateAroundZ ( G4int nstep, G4double phi, G4double dphi, G4int np1, G4int np2, const G4double * z, G4double * r, G4int nodeVis, G4int edgeVis )

protected

Definition at line 553 of file HepPolyhedron.cc.

{
  static const G4double wholeCircle   = twopi;
 
  //   S E T   R O T A T I O N   P A R A M E T E R S
 
  G4bool ifWholeCircle = std::abs(dphi-wholeCircle) < perMillion;
  G4double delPhi = ifWholeCircle ? wholeCircle : dphi;
  G4int nSphi = nstep;
  if (nSphi <= 0) nSphi = GetNumberOfRotationSteps()*delPhi/wholeCircle + 0.5;
  if (nSphi == 0) nSphi = 1;
  G4int nVphi = ifWholeCircle ? nSphi : nSphi + 1;
  G4bool ifClosed = np1 <= 0; // true if external polyline is closed
 
  //   C O U N T   V E R T I C E S
 
  G4int absNp1 = std::abs(np1);
  G4int absNp2 = std::abs(np2);
  G4int i1beg = 0;
  G4int i1end = absNp1-1;
  G4int i2beg = absNp1;
  G4int i2end = absNp1+absNp2-1;
  G4int i, j, k;
 
  for(i=i1beg; i<=i2end; i++) {
    if (std::abs(r[i]) < spatialTolerance) r[i] = 0.;
  }
 
  // external polyline - check position of nodes relative to Z
  //
  G4int Nverts = 0;
  for (i=i1beg; i<=i1end; i++) {
    Nverts += (r[i] == 0.) ? 1 : nVphi;
  }
 
  // internal polyline
  //
  G4bool ifSide1 = false; // whether to create bottom faces
  G4bool ifSide2 = false; // whether to create top faces
 
  if (r[i2beg] != r[i1beg] || z[i2beg] != z[i1beg]) { // first node
    Nverts += (r[i2beg] == 0.) ? 1 : nVphi;
    ifSide1 = true;
  }
 
  for(i=i2beg+1; i<i2end; i++) { // intermediate nodes
    Nverts += (r[i] == 0.) ? 1 : nVphi;
  }
 
  if (r[i2end] != r[i1end] || z[i2end] != z[i1end]) { // last node
    if (absNp2 > 1) Nverts += (r[i2end] == 0.) ? 1 : nVphi;
    ifSide2 = true;
  }
 
  //   C O U N T   F A C E S
 
  // external lateral faces
  //
  G4int Nfaces = ifClosed ? absNp1*nSphi : (absNp1-1)*nSphi;
 
  // internal lateral faces
  //
  if (absNp2 > 1) {
    for(i=i2beg; i<i2end; i++) {
      if (r[i] > 0. || r[i+1] > 0.) Nfaces += nSphi;
    }
 
    if (ifClosed) {
      if (r[i2end] > 0. || r[i2beg] > 0.) Nfaces += nSphi;
    }
  }
 
  // bottom and top faces
  //
  if (!ifClosed) {
    if (ifSide1 && (r[i1beg] > 0. || r[i2beg] > 0.)) Nfaces += nSphi;
    if (ifSide2 && (r[i1end] > 0. || r[i2end] > 0.)) Nfaces += nSphi;
  }
 
  // phi_wedge faces
  //
  if (!ifWholeCircle) {
    Nfaces += ifClosed ? 2*absNp1 : 2*(absNp1-1);
  }
 
  //   A L L O C A T E   M E M O R Y
 
  AllocateMemory(Nverts, Nfaces);
  if (pV == nullptr || pF == nullptr) return;
 
  //   G E N E R A T E   V E R T I C E S
 
  G4int *kk; // array of start indices along polylines
  kk = new G4int[absNp1+absNp2];
 
  // external polyline
  //
  k = 1; // free position in array of vertices pV
  for(i=i1beg; i<=i1end; i++) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }
 
  // first point of internal polyline
  //
  i = i2beg;
  if (ifSide1) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }else{
    kk[i] = kk[i1beg];
  }
 
  // intermediate points of internal polyline
  //
  for(i=i2beg+1; i<i2end; i++) {
    kk[i] = k;
    if (r[i] == 0.)
    { pV[k++] = G4Point3D(0, 0, z[i]); } else { k += nVphi; }
  }
 
  // last point of internal polyline
  //
  if (absNp2 > 1) {
    i = i2end;
    if (ifSide2) {
      kk[i] = k;
      if (r[i] == 0.) pV[k] = G4Point3D(0, 0, z[i]);
    }else{
      kk[i] = kk[i1end];
    }
  }
 
  // set vertices
  //
  G4double cosPhi, sinPhi;
 
  for(j=0; j<nVphi; j++) {
    cosPhi = std::cos(phi+j*delPhi/nSphi);
    sinPhi = std::sin(phi+j*delPhi/nSphi);
    for(i=i1beg; i<=i2end; i++) {
      if (r[i] != 0.)
        pV[kk[i]+j] = G4Point3D(r[i]*cosPhi,r[i]*sinPhi,z[i]);
    }
  }
 
  //   G E N E R A T E   F A C E S
 
  //  external faces
  //
  G4int v1,v2;
 
  k = 1; // free position in array of faces pF
  v2 = ifClosed ? nodeVis : 1;
  for(i=i1beg; i<i1end; i++) {
    v1 = v2;
    if (!ifClosed && i == i1end-1) {
      v2 = 1;
    }else{
      v2 = (r[i] == r[i+1] && r[i+1] == r[i+2]) ? -1 : nodeVis;
    }
    RotateEdge(kk[i], kk[i+1], r[i], r[i+1], v1, v2,
               edgeVis, ifWholeCircle, nSphi, k);
  }
  if (ifClosed) {
    RotateEdge(kk[i1end], kk[i1beg], r[i1end],r[i1beg], nodeVis, nodeVis,
               edgeVis, ifWholeCircle, nSphi, k);
  }
 
  // internal faces
  //
  if (absNp2 > 1) {
    v2 = ifClosed ? nodeVis : 1;
    for(i=i2beg; i<i2end; i++) {
      v1 = v2;
      if (!ifClosed && i==i2end-1) {
        v2 = 1;
      }else{
        v2 = (r[i] == r[i+1] && r[i+1] == r[i+2]) ? -1 :  nodeVis;
      }
      RotateEdge(kk[i+1], kk[i], r[i+1], r[i], v2, v1,
                 edgeVis, ifWholeCircle, nSphi, k);
    }
    if (ifClosed) {
      RotateEdge(kk[i2beg], kk[i2end], r[i2beg], r[i2end], nodeVis, nodeVis,
                 edgeVis, ifWholeCircle, nSphi, k);
    }
  }
 
  // bottom and top faces
  //
  if (!ifClosed) {
    if (ifSide1) {
      RotateEdge(kk[i2beg], kk[i1beg], r[i2beg], r[i1beg], 1, 1,
                 -1, ifWholeCircle, nSphi, k);
    }
    if (ifSide2) {
      RotateEdge(kk[i1end], kk[i2end], r[i1end], r[i2end], 1, 1,
                 -1, ifWholeCircle, nSphi, k);
    }
  }
 
  // phi_wedge faces in case of incomplete circle
  //
  if (!ifWholeCircle) {
 
    G4int  ii[4], vv[4];
 
    if (ifClosed) {
      for (i=i1beg; i<=i1end; i++) {
        ii[0] = i;
        ii[3] = (i == i1end) ? i1beg : i+1;
        ii[1] = (absNp2 == 1) ? i2beg : ii[0]+absNp1;
        ii[2] = (absNp2 == 1) ? i2beg : ii[3]+absNp1;
        vv[0] = -1;
        vv[1] = 1;
        vv[2] = -1;
        vv[3] = 1;
        SetSideFacets(ii, vv, kk, r, delPhi, nSphi, k);
      }
    }else{
      for (i=i1beg; i<i1end; i++) {
        ii[0] = i;
        ii[3] = i+1;
        ii[1] = (absNp2 == 1) ? i2beg : ii[0]+absNp1;
        ii[2] = (absNp2 == 1) ? i2beg : ii[3]+absNp1;
        vv[0] = (i == i1beg)   ? 1 : -1;
        vv[1] = 1;
        vv[2] = (i == i1end-1) ? 1 : -1;
        vv[3] = 1;
        SetSideFacets(ii, vv, kk, r, delPhi, nSphi, k);
      }
    }
  }
 
  delete [] kk; // free memory
 
  // final check
  //
  if (k-1 != nface) {
    std::cerr
      << "HepPolyhedron::RotateAroundZ: number of generated faces ("
      << k-1 << ") is not equal to the number of allocated faces ("
      << nface << ")"
      << std::endl;
  }
}

Referenced by HepPolyhedronCons::HepPolyhedronCons(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronPgon::HepPolyhedronPgon(), HepPolyhedronSphere::HepPolyhedronSphere(), and HepPolyhedronTorus::HepPolyhedronTorus().

RotateContourAroundZ()

void HepPolyhedron::RotateContourAroundZ ( G4int nstep, G4double phi, G4double dphi, const std::vector< G4TwoVector > & rz, G4int nodeVis, G4int edgeVis )

protected

Definition at line 828 of file HepPolyhedron.cc.

{
  //   S E T   R O T A T I O N   P A R A M E T E R S
 
  G4bool ifWholeCircle = std::abs(dphi - twopi) < perMillion;
  G4double delPhi = (ifWholeCircle) ? twopi : dphi;
  G4int nSphi = nstep;
  if (nSphi <= 0) nSphi = GetNumberOfRotationSteps()*delPhi/twopi + 0.5;
  if (nSphi == 0) nSphi = 1;
  G4int nVphi = (ifWholeCircle) ? nSphi : nSphi + 1;
 
  //   C A L C U L A T E   A R E A
 
  G4int Nrz = (G4int)rz.size();
  G4double area = 0;
  for (G4int i = 0; i < Nrz; ++i)
  {
    G4int k = (i == 0) ? Nrz - 1 : i - 1;
    area += rz[k].x()*rz[i].y() - rz[i].x()*rz[k].y();
  }
 
  //   P R E P A R E   P O L Y L I N E
 
  auto r = new G4double[Nrz];
  auto z = new G4double[Nrz];
  for (G4int i = 0; i < Nrz; ++i)
  {
    r[i] = rz[i].x();
    z[i] = rz[i].y();
    if (std::abs(r[i]) < spatialTolerance) r[i] = 0.;
  }
 
  //   C O U N T   V E R T I C E S   A N D   F A C E S
 
  G4int Nverts = 0;
  for(G4int i = 0; i < Nrz; ++i) Nverts += (r[i] == 0.) ? 1 : nVphi;
 
  G4int Nedges = Nrz;
  for (G4int i = 0; i < Nrz; ++i)
  {
    G4int k = (i == 0) ? Nrz - 1 : i - 1;
    Nedges -= static_cast<int>(r[k] == 0 && r[i] == 0);
  }
 
  G4int Nfaces = Nedges*nSphi;               // lateral faces
  if (!ifWholeCircle) Nfaces += 2*(Nrz - 2); // phi_wedge faces
 
  //   A L L O C A T E   M E M O R Y
 
  AllocateMemory(Nverts, Nfaces);
  if (pV == nullptr || pF == nullptr)
  {
    delete [] r;
    delete [] z;
    return;
  }
 
  //   S E T   V E R T I C E S
 
  auto kk = new G4int[Nrz]; // start indices along contour
  G4int kfree = 1; // current free position in array of vertices pV
 
  // set start indices, set vertices for nodes with r == 0
  for(G4int i = 0; i < Nrz; ++i)
  {
    kk[i] = kfree;
    if (r[i] == 0.) pV[kfree++] = G4Point3D(0, 0, z[i]);
    if (r[i] != 0.) kfree += nVphi;
  }
 
  // set vertices by rotating r
  for(G4int j = 0; j < nVphi; ++j)
  {
    G4double cosPhi = std::cos(phi + j*delPhi/nSphi);
    G4double sinPhi = std::sin(phi + j*delPhi/nSphi);
    for(G4int i = 0; i < Nrz; ++i)
    {
      if (r[i] != 0.)
        pV[kk[i] + j] = G4Point3D(r[i]*cosPhi, r[i]*sinPhi, z[i]);
    }
  }
 
  //   S E T   F A C E S
 
  kfree = 1; // current free position in array of faces pF
  for(G4int i = 0; i < Nrz; ++i)
  {
    G4int i1 = (i < Nrz - 1) ? i + 1 : 0; // inverse order if area > 0
    G4int i2 = i;
    if (area < 0.) std::swap(i1, i2);
    RotateEdge(kk[i1], kk[i2], r[i1], r[i2], nodeVis, nodeVis,
               edgeVis, ifWholeCircle, nSphi, kfree);
  }
 
  //    S E T   P H I _ W E D G E   F A C E S
 
  if (!ifWholeCircle)
  {
    std::vector<G4int> triangles;
    TriangulatePolygon(rz, triangles);
 
    G4int ii[4], vv[4];
    G4int ntria = G4int(triangles.size()/3);
    for (G4int i = 0; i < ntria; ++i)
    {
      G4int i1 = triangles[0 + i*3];
      G4int i2 = triangles[1 + i*3];
      G4int i3 = triangles[2 + i*3];
      if (area < 0.) std::swap(i1, i3);
      G4int v1 = (std::abs(i2-i1) == 1 || std::abs(i2-i1) == Nrz-1) ? 1 : -1;
      G4int v2 = (std::abs(i3-i2) == 1 || std::abs(i3-i2) == Nrz-1) ? 1 : -1;
      G4int v3 = (std::abs(i1-i3) == 1 || std::abs(i1-i3) == Nrz-1) ? 1 : -1;
      ii[0] = i1; ii[1] = i2; ii[2] = i2; ii[3] = i3;
      vv[0] = v1; vv[1] = -1; vv[2] = v2; vv[3] = v3;
      SetSideFacets(ii, vv, kk, r, delPhi, nSphi, kfree);
    }
  }
 
  // free memory
  delete [] r;
  delete [] z;
  delete [] kk;
 
  // final check
  if (kfree - 1 != nface)
  {
    std::cerr
      << "HepPolyhedron::RotateContourAroundZ: number of generated faces ("
      << kfree-1 << ") is not equal to the number of allocated faces ("
      << nface << ")"
      << std::endl;
  }
}

Referenced by HepPolyhedronPgon::HepPolyhedronPgon().

RotateEdge()

void HepPolyhedron::RotateEdge ( G4int k1, G4int k2, G4double r1, G4double r2, G4int v1, G4int v2, G4int vEdge, G4bool ifWholeCircle, G4int ns, G4int & kface )

protected

Definition at line 420 of file HepPolyhedron.cc.

{
  if (r1 == 0. && r2 == 0.) return;
 
  G4int i;
  G4int i1  = k1;
  G4int i2  = k2;
  G4int ii1 = ifWholeCircle ? i1 : i1+nds;
  G4int ii2 = ifWholeCircle ? i2 : i2+nds;
  G4int vv  = ifWholeCircle ? vEdge : 1;
 
  if (nds == 1) {
    if (r1 == 0.) {
      pF[kface++]   = G4Facet(i1,0,    v2*i2,0, (i2+1),0);
    }else if (r2 == 0.) {
      pF[kface++]   = G4Facet(i1,0,    i2,0,    v1*(i1+1),0);
    }else{
      pF[kface++]   = G4Facet(i1,0,    v2*i2,0, (i2+1),0, v1*(i1+1),0);
    }
  }else{
    if (r1 == 0.) {
      pF[kface++]   = G4Facet(vv*i1,0,    v2*i2,0, vEdge*(i2+1),0);
      for (i2++,i=1; i<nds-1; i2++,i++) {
        pF[kface++] = G4Facet(vEdge*i1,0, v2*i2,0, vEdge*(i2+1),0);
      }
      pF[kface++]   = G4Facet(vEdge*i1,0, v2*i2,0, vv*ii2,0);
    }else if (r2 == 0.) {
      pF[kface++]   = G4Facet(vv*i1,0,    vEdge*i2,0, v1*(i1+1),0);
      for (i1++,i=1; i<nds-1; i1++,i++) {
        pF[kface++] = G4Facet(vEdge*i1,0, vEdge*i2,0, v1*(i1+1),0);
      }
      pF[kface++]   = G4Facet(vEdge*i1,0, vv*i2,0,    v1*ii1,0);
    }else{
      pF[kface++]   = G4Facet(vv*i1,0,    v2*i2,0, vEdge*(i2+1),0,v1*(i1+1),0);
      for (i1++,i2++,i=1; i<nds-1; i1++,i2++,i++) {
        pF[kface++] = G4Facet(vEdge*i1,0, v2*i2,0, vEdge*(i2+1),0,v1*(i1+1),0);
      }
      pF[kface++]   = G4Facet(vEdge*i1,0, v2*i2,0, vv*ii2,0,      v1*ii1,0);
    }
  }
}

Referenced by RotateAroundZ(), and RotateContourAroundZ().

SetFacet()

void HepPolyhedron::SetFacet	(	G4int	index,
		G4int	iv1,
		G4int	iv2,
		G4int	iv3,
		G4int	iv4 = 0 )

Definition at line 305 of file HepPolyhedron.cc.

{
  if (index < 1 || index > nface)
  {
    std::cerr
      << "HepPolyhedron::SetFacet: facet index = " << index
      << " is out of range\n"
      << "   N. of vertices = " << nvert << "\n"
      << "   N. of facets = " << nface << std::endl;
    return;
  }
  if (iv1 < 1 || iv1 > nvert ||
      iv2 < 1 || iv2 > nvert ||
      iv3 < 1 || iv3 > nvert ||
      iv4 < 0 || iv4 > nvert)
  {
    std::cerr
      << "HepPolyhedron::SetFacet: incorrectly specified facet"
      << " (" << iv1 << ", " << iv2 << ", " << iv3 << ", " << iv4 << ")\n"
      << "   N. of vertices = " << nvert << "\n"
      << "   N. of facets = " << nface << std::endl;
    return;
  }
  pF[index] = G4Facet(iv1, 0, iv2, 0, iv3, 0, iv4, 0);
}

Referenced by G4GenericTrap::CreatePolyhedron(), HepPolyhedronBoxMesh::HepPolyhedronBoxMesh(), and HepPolyhedronTetMesh::HepPolyhedronTetMesh().

SetNumberOfRotationSteps()

void HepPolyhedron::SetNumberOfRotationSteps ( G4int n )

static

Definition at line 339 of file HepPolyhedron.cc.

{
  const G4int nMin = 3;
  if (n < nMin) {
    std::cerr
      << "HepPolyhedron::SetNumberOfRotationSteps: attempt to set the\n"
      << "number of steps per circle < " << nMin << "; forced to " << nMin
      << std::endl;
    fNumberOfRotationSteps = nMin;
  }else{
    fNumberOfRotationSteps = n;
  }
}

Referenced by G4ArrowModel::G4ArrowModel(), and G4VSceneHandler::RequestPrimitives().

SetReferences()

void HepPolyhedron::SetReferences

(

)

Definition at line 1115 of file HepPolyhedron.cc.

{
  if (nface <= 0) return;
 
  struct edgeListMember {
    edgeListMember *next;
    G4int v2;
    G4int iface;
    G4int iedge;
  } *edgeList, *freeList, **headList;
 
 
  //   A L L O C A T E   A N D   I N I T I A T E   L I S T S
 
  edgeList = new edgeListMember[2*nface];
  headList = new edgeListMember*[nvert];
 
  G4int i;
  for (i=0; i<nvert; i++) {
    headList[i] = nullptr;
  }
  freeList = edgeList;
  for (i=0; i<2*nface-1; i++) {
    edgeList[i].next = &edgeList[i+1];
  }
  edgeList[2*nface-1].next = nullptr;
 
  //   L O O P   A L O N G   E D G E S
 
  G4int iface, iedge, nedge, i1, i2, k1, k2;
  edgeListMember *prev, *cur;
 
  for(iface=1; iface<=nface; iface++) {
    nedge = (pF[iface].edge[3].v == 0) ? 3 : 4;
    for (iedge=0; iedge<nedge; iedge++) {
      i1 = iedge;
      i2 = (iedge < nedge-1) ? iedge+1 : 0;
      i1 = std::abs(pF[iface].edge[i1].v);
      i2 = std::abs(pF[iface].edge[i2].v);
      k1 = (i1 < i2) ? i1 : i2;          // k1 = ::min(i1,i2);
      k2 = (i1 > i2) ? i1 : i2;          // k2 = ::max(i1,i2);
 
      // check head of the List corresponding to k1
      cur = headList[k1];
      if (cur == nullptr) {
        headList[k1] = freeList;
        if (freeList == nullptr) {
          std::cerr
          << "Polyhedron::SetReferences: bad link "
          << std::endl;
          break;
        }
        freeList = freeList->next;
        cur = headList[k1];
        cur->next = nullptr;
        cur->v2 = k2;
        cur->iface = iface;
        cur->iedge = iedge;
        continue;
      }
 
      if (cur->v2 == k2) {
        headList[k1] = cur->next;
        cur->next = freeList;
        freeList = cur;
        pF[iface].edge[iedge].f = cur->iface;
        pF[cur->iface].edge[cur->iedge].f = iface;
        i1 = (pF[iface].edge[iedge].v < 0) ? -1 : 1;
        i2 = (pF[cur->iface].edge[cur->iedge].v < 0) ? -1 : 1;
        if (i1 != i2) {
          std::cerr
            << "Polyhedron::SetReferences: different edge visibility "
            << iface << "/" << iedge << "/"
            << pF[iface].edge[iedge].v << " and "
            << cur->iface << "/" << cur->iedge << "/"
            << pF[cur->iface].edge[cur->iedge].v
            << std::endl;
        }
        continue;
      }
 
      // check List itself
      for (;;) {
        prev = cur;
        cur = prev->next;
        if (cur == nullptr) {
          prev->next = freeList;
          if (freeList == nullptr) {
            std::cerr
            << "Polyhedron::SetReferences: bad link "
            << std::endl;
            break;
          }
          freeList = freeList->next;
          cur = prev->next;
          cur->next = nullptr;
          cur->v2 = k2;
          cur->iface = iface;
          cur->iedge = iedge;
          break;
        }
 
        if (cur->v2 == k2) {
          prev->next = cur->next;
          cur->next = freeList;
          freeList = cur;
          pF[iface].edge[iedge].f = cur->iface;
          pF[cur->iface].edge[cur->iedge].f = iface;
          i1 = (pF[iface].edge[iedge].v < 0) ? -1 : 1;
          i2 = (pF[cur->iface].edge[cur->iedge].v < 0) ? -1 : 1;
            if (i1 != i2) {
              std::cerr
                << "Polyhedron::SetReferences: different edge visibility "
                << iface << "/" << iedge << "/"
                << pF[iface].edge[iedge].v << " and "
                << cur->iface << "/" << cur->iedge << "/"
                << pF[cur->iface].edge[cur->iedge].v
                << std::endl;
            }
          break;
        }
      }
    }
  }
 
  //  C H E C K   T H A T   A L L   L I S T S   A R E   E M P T Y
 
  for (i=0; i<nvert; i++) {
    if (headList[i] != nullptr) {
      std::cerr
        << "Polyhedron::SetReferences: List " << i << " is not empty"
        << std::endl;
    }
  }
 
  //   F R E E   M E M O R Y
 
  delete [] edgeList;
  delete [] headList;
}

Referenced by G4GenericTrap::CreatePolyhedron(), createPolyhedron(), HepPolyhedronBoxMesh::HepPolyhedronBoxMesh(), HepPolyhedronCons::HepPolyhedronCons(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronPgon::HepPolyhedronPgon(), HepPolyhedronPgon::HepPolyhedronPgon(), HepPolyhedronSphere::HepPolyhedronSphere(), HepPolyhedronTetMesh::HepPolyhedronTetMesh(), HepPolyhedronTorus::HepPolyhedronTorus(), JoinCoplanarFacets(), and G4PolyhedronArbitrary::SetReferences().

SetSideFacets()

void HepPolyhedron::SetSideFacets ( G4int ii[4], G4int vv[4], G4int * kk, G4double * r, G4double dphi, G4int ns, G4int & kface )

protected

Definition at line 482 of file HepPolyhedron.cc.

{
  G4int k1, k2, k3, k4;
 
  if (std::abs(dphi-pi) < perMillion) { // half a circle
    for (G4int i=0; i<4; i++) {
      k1 = ii[i];
      k2 = ii[(i+1)%4];
      if (r[k1] == 0. && r[k2] == 0.) vv[i] = -1;
    }
  }
 
  if (ii[1] == ii[2]) {
    k1 = kk[ii[0]];
    k2 = kk[ii[2]];
    k3 = kk[ii[3]];
    pF[kface++] = G4Facet(vv[0]*k1,0, vv[2]*k2,0, vv[3]*k3,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[2]] != 0.) k2 += nds;
    if (r[ii[3]] != 0.) k3 += nds;
    pF[kface++] = G4Facet(vv[2]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
  }else if (kk[ii[0]] == kk[ii[1]]) {
    k1 = kk[ii[0]];
    k2 = kk[ii[2]];
    k3 = kk[ii[3]];
    pF[kface++] = G4Facet(vv[1]*k1,0, vv[2]*k2,0, vv[3]*k3,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[2]] != 0.) k2 += nds;
    if (r[ii[3]] != 0.) k3 += nds;
    pF[kface++] = G4Facet(vv[2]*k3,0, vv[1]*k2,0, vv[3]*k1,0);
  }else if (kk[ii[2]] == kk[ii[3]]) {
    k1 = kk[ii[0]];
    k2 = kk[ii[1]];
    k3 = kk[ii[2]];
    pF[kface++] = G4Facet(vv[0]*k1,0, vv[1]*k2,0, vv[3]*k3,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[1]] != 0.) k2 += nds;
    if (r[ii[2]] != 0.) k3 += nds;
    pF[kface++] = G4Facet(vv[1]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
  }else{
    k1 = kk[ii[0]];
    k2 = kk[ii[1]];
    k3 = kk[ii[2]];
    k4 = kk[ii[3]];
    pF[kface++] = G4Facet(vv[0]*k1,0, vv[1]*k2,0, vv[2]*k3,0, vv[3]*k4,0);
    if (r[ii[0]] != 0.) k1 += nds;
    if (r[ii[1]] != 0.) k2 += nds;
    if (r[ii[2]] != 0.) k3 += nds;
    if (r[ii[3]] != 0.) k4 += nds;
    pF[kface++] = G4Facet(vv[2]*k4,0, vv[1]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
  }
}

Referenced by RotateAroundZ(), and RotateContourAroundZ().

SetVertex()

void HepPolyhedron::SetVertex	(	G4int	index,
		const G4Point3D &	v )

Definition at line 282 of file HepPolyhedron.cc.

{
  if (index < 1 || index > nvert)
  {
    std::cerr
      << "HepPolyhedron::SetVertex: vertex index = " << index
      << " is out of range\n"
      << "   N. of vertices = " << nvert << "\n"
      << "   N. of facets = " << nface << std::endl;
    return;
  }
  pV[index] = v;
}

Referenced by G4GenericTrap::CreatePolyhedron(), HepPolyhedronBoxMesh::HepPolyhedronBoxMesh(), and HepPolyhedronTetMesh::HepPolyhedronTetMesh().

subtract()

HepPolyhedron HepPolyhedron::subtract

(

const HepPolyhedron &

p

)

const

Definition at line 3391 of file HepPolyhedron.cc.

{
  G4int ierr;
  BooleanProcessor processor;
  return processor.execute(OP_SUBTRACTION, *this, p,ierr);
}

Transform()

HepPolyhedron & HepPolyhedron::Transform

(

const G4Transform3D &

t

)

Definition at line 1379 of file HepPolyhedron.cc.

{
  if (nvert > 0) {
    for (G4int i=1; i<=nvert; i++) { pV[i] = t * pV[i]; }
 
    //  C H E C K   D E T E R M I N A N T   A N D
    //  I N V E R T   F A C E T S   I F   I T   I S   N E G A T I V E
 
    G4Vector3D d = t * G4Vector3D(0,0,0);
    G4Vector3D x = t * G4Vector3D(1,0,0) - d;
    G4Vector3D y = t * G4Vector3D(0,1,0) - d;
    G4Vector3D z = t * G4Vector3D(0,0,1) - d;
    if ((x.cross(y))*z < 0) InvertFacets();
  }
  return *this;
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4DisplacedSolid::CreatePolyhedron(), G4EllipticalTube::CreatePolyhedron(), G4ReflectedSolid::CreatePolyhedron(), G4ScaledSolid::CreatePolyhedron(), G4ScoringBox::Draw(), G4ScoringCylinder::Draw(), G4ScoringBox::DrawColumn(), G4ScoringCylinder::DrawColumn(), G4ArrowModel::G4ArrowModel(), and G4ASCIITreeSceneHandler::RequestPrimitives().

TriangulatePolygon()

G4bool HepPolyhedron::TriangulatePolygon ( const std::vector< G4TwoVector > & polygon, std::vector< G4int > & result )

protected

Definition at line 985 of file HepPolyhedron.cc.

{
  result.resize(0);
  G4int n = (G4int)polygon.size();
  if (n < 3) return false;
 
  // calculate area
  //
  G4double area = 0.;
  for(G4int i = 0; i < n; ++i)
  {
    G4int k = (i == 0) ? n - 1 : i - 1;
    area += polygon[k].x()*polygon[i].y() - polygon[i].x()*polygon[k].y();
  }
 
  // allocate and initialize list of Vertices
  // we want a counter-clockwise polygon in V
  //
  auto  V = new G4int[n];
  if (area > 0.)
    for (G4int i = 0; i < n; ++i) V[i] = i;
  else
    for (G4int i = 0; i < n; ++i) V[i] = (n - 1) - i;
 
  //  Triangulation: remove nv-2 Vertices, creating 1 triangle every time
  //
  G4int nv = n;
  G4int count = 2*nv; // error detection counter
  for(G4int b = nv - 1; nv > 2; )
  {
    // ERROR: if we loop, it is probably a non-simple polygon
    if ((count--) <= 0)
    {
      delete [] V;
      if (area < 0.) std::reverse(result.begin(),result.end());
      return false;
    }
 
    // three consecutive vertices in current polygon, <a,b,c>
    G4int a = (b   < nv) ? b   : 0; // previous
          b = (a+1 < nv) ? a+1 : 0; // current
    G4int c = (b+1 < nv) ? b+1 : 0; // next
 
    if (CheckSnip(polygon, a,b,c, nv,V))
    {
      // output Triangle
      result.push_back(V[a]);
      result.push_back(V[b]);
      result.push_back(V[c]);
 
      // remove vertex b from remaining polygon
      nv--;
      for(G4int i = b; i < nv; ++i) V[i] = V[i+1];
 
      count = 2*nv; // resest error detection counter
    }
  }
  delete [] V;
  if (area < 0.) std::reverse(result.begin(),result.end());
  return true;
}

Referenced by RotateContourAroundZ().

vertexUnweightedMean()

G4Point3D HepPolyhedron::vertexUnweightedMean

(

)

const

Calculate the unweighted mean of all the vertices in the polyhedron. Not to be confused with the polyhedron centre or centre of mass

Returns

G4Point3D of the unweighted mean vertex position

Definition at line 1932 of file HepPolyhedron.cc.

                                                    {
  /***********************************************************************
   *                                                                     *
   * Name: vertexUnweightedMean                        Date:    23.10.23 *
   * Author: S. Boogert (Manchester)                   Revised:          *
   *                                                                     *
   * Function: Calculate the unweighted mean of all the vertices         *
   * in the polyhedron. Not to be confused with the polyhedron centre or *
   * centre of mass                                                      *
   ***********************************************************************/
 
  auto centre = G4Point3D();
  for(int i=1;i<=nvert;i++) {
    centre += pV[i];
  }
  centre = centre/nvert;
  return centre;
}

Referenced by G4VtkStore::AddPrimitiveAppend(), G4VtkStore::AddPrimitiveTensorGlyph(), and G4VtkStore::AddPrimitiveTransformBake().

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & ostr, const HepPolyhedron & ph )

friend

Definition at line 105 of file HepPolyhedron.cc.

                                                                     {
  ostr << std::endl;
  ostr << "Nvertices=" << ph.nvert << ", Nfacets=" << ph.nface << std::endl;
  G4int i;
  for (i=1; i<=ph.nvert; i++) {
     ostr << "xyz(" << i << ")="
          << ph.pV[i].x() << ' ' << ph.pV[i].y() << ' ' << ph.pV[i].z()
          << std::endl;
  }
  for (i=1; i<=ph.nface; i++) {
    ostr << "face(" << i << ")=" << ph.pF[i] << std::endl;
  }
  return ostr;
}

Member Data Documentation

fNumberOfRotationSteps

G4ThreadLocal G4int HepPolyhedron::fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

staticprotected

Definition at line 235 of file HepPolyhedron.h.

Referenced by G4Polyhedron::G4Polyhedron(), GetNumberOfRotationSteps(), ResetNumberOfRotationSteps(), and SetNumberOfRotationSteps().

nface

G4int HepPolyhedron::nface

protected

Definition at line 236 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddFacet(), AllocateMemory(), GetNoFacets(), GetSurfaceArea(), GetVolume(), HepPolyhedron(), HepPolyhedron(), InvertFacets(), JoinCoplanarFacets(), operator=(), operator=(), RotateAroundZ(), RotateContourAroundZ(), SetFacet(), SetReferences(), and SetVertex().

nvert

G4int HepPolyhedron::nvert

protected

Definition at line 236 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddFacet(), G4PolyhedronArbitrary::AddVertex(), AllocateMemory(), createPolyhedron(), GetNoVerteces(), GetNoVertices(), HepPolyhedron(), HepPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), operator=(), operator=(), SetFacet(), SetReferences(), SetVertex(), Transform(), and vertexUnweightedMean().

pF

G4Facet* HepPolyhedron::pF

protected

Definition at line 238 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddFacet(), AllocateMemory(), createPolyhedron(), CreatePrism(), createTwistedTrap(), GetSurfaceArea(), GetVolume(), HepPolyhedron(), HepPolyhedron(), HepPolyhedronTet::HepPolyhedronTet(), InvertFacets(), JoinCoplanarFacets(), operator=(), operator=(), RotateAroundZ(), RotateContourAroundZ(), RotateEdge(), SetFacet(), SetReferences(), SetSideFacets(), and ~HepPolyhedron().

pV

G4Point3D* HepPolyhedron::pV

protected

Definition at line 237 of file HepPolyhedron.h.

Referenced by G4PolyhedronArbitrary::AddVertex(), AllocateMemory(), createPolyhedron(), createTwistedTrap(), GetSurfaceArea(), GetVolume(), HepPolyhedron(), HepPolyhedron(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronTet::HepPolyhedronTet(), HepPolyhedronTrap::HepPolyhedronTrap(), HepPolyhedronTrd2::HepPolyhedronTrd2(), JoinCoplanarFacets(), operator=(), operator=(), RotateAroundZ(), RotateContourAroundZ(), SetVertex(), Transform(), vertexUnweightedMean(), and ~HepPolyhedron().

---

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

• HepPolyhedron.h
• HepPolyhedron.cc