HepPolyhedron Class Reference

#include <HepPolyhedron.h>

Inheritance diagram for HepPolyhedron:

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

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

Protected Member Functions
void	AllocateMemory (G4int Nvert, G4int Nface)
G4bool	CheckSnip (const std::vector< G4TwoVector > &contour, G4int a, G4int b, G4int c, G4int n, const G4int *V)
void	CreatePrism ()
G4int	FindNeighbour (G4int iFace, G4int iNode, G4int iOrder) const
G4Normal3D	FindNodeNormal (G4int iFace, G4int iNode) const
void	InvertFacets ()
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)
void	RotateEdge (G4int k1, G4int k2, G4double r1, G4double r2, G4int v1, G4int v2, G4int vEdge, G4bool ifWholeCircle, G4int ns, G4int &kface)
void	SetReferences ()
void	SetSideFacets (G4int ii[4], G4int vv[4], G4int *kk, G4double *r, G4double dphi, G4int ns, G4int &kface)
G4bool	TriangulatePolygon (const std::vector< G4TwoVector > &polygon, std::vector< G4int > &result)

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

Static Protected Attributes
static G4ThreadLocal G4int	fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

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

Detailed Description

Definition at line 213 of file HepPolyhedron.h.

Constructor & Destructor Documentation

HepPolyhedron() [1/3]

HepPolyhedron::HepPolyhedron ( )

inline

Definition at line 272 of file HepPolyhedron.h.

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

HepPolyhedron() [2/3]

HepPolyhedron::HepPolyhedron

(

const HepPolyhedron &

from

)

Definition at line 111 of file HepPolyhedron.cc.

: nvert(0), nface(0), pV(0), pF(0)
{
  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];
}

References AllocateMemory(), nface, nvert, pF, and pV.

HepPolyhedron() [3/3]

HepPolyhedron::HepPolyhedron

(

HepPolyhedron &&

from

)

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

References nface, nvert, pF, and pV.

~HepPolyhedron()

virtual HepPolyhedron::~HepPolyhedron ( )

inlinevirtual

Definition at line 281 of file HepPolyhedron.h.

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

References pF, and pV.

Member Function Documentation

add()

HepPolyhedron HepPolyhedron::add

(

const HepPolyhedron &

p

)

const

Definition at line 2788 of file HepPolyhedron.cc.

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

References processor.

AllocateMemory()

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

protected

Definition at line 296 of file HepPolyhedron.cc.

{
  if (nvert == Nvert && nface == Nface) return;
  if (pV != 0) delete [] pV;
  if (pF != 0) 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 = 0; pF = 0;
  }
}

References nface, nvert, pF, and pV.

Referenced by createPolyhedron(), createTwistedTrap(), G4PolyhedronArbitrary::G4PolyhedronArbitrary(), HepPolyhedron(), HepPolyhedronTet::HepPolyhedronTet(), 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 985 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;
}

References kCarTolerance, G4INCL::Math::max(), G4INCL::Math::min(), and CLHEP::detail::n.

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

References AllocateMemory(), nvert, pF, pV, and SetReferences().

Referenced by G4CutTubs::CreatePolyhedron(), G4Tet::CreatePolyhedron(), G4TwistedTubs::CreatePolyhedron(), and G4VTwistedFaceted::CreatePolyhedron().

CreatePrism()

void HepPolyhedron::CreatePrism ( )

protected

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

References pF.

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

References AllocateMemory(), pF, and pV.

FindNeighbour()

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

protected

Definition at line 192 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 220 of file HepPolyhedron.cc.

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

References CLHEP::detail::n, and CLHEP::normal().

GetFacet() [1/2]

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

Definition at line 1444 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 != 0) iFaces[i] = pF[iFace].edge[i].f;
      if (k > 0) {
        iNodes[i] = k;
        if (edgeFlags != 0) edgeFlags[i] = 1;
      }else{
        iNodes[i] = -k;
        if (edgeFlags != 0) edgeFlags[i] = -1;
      }
    }
    n = i;
  }
}

References CLHEP::detail::n.

Referenced by G4CutTubs::CreatePolyhedron().

GetFacet() [2/2]

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

Definition at line 1478 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 != 0) normals[i] = FindNodeNormal(index,iNodes[i]);
    }
  }
}

References CLHEP::detail::n, and geant4_check_module_cycles::nodes.

GetNextEdge() [1/2]

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

Definition at line 1403 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(), and G4GMocrenFileSceneHandler::ExtractDetector().

GetNextEdge() [2/2]

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

Definition at line 1424 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 321 of file HepPolyhedron.h.

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

References GetNextEdgeIndices().

GetNextEdgeIndeces() [2/2]

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

inline

Definition at line 315 of file HepPolyhedron.h.

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

References GetNextEdgeIndices().

GetNextEdgeIndices() [1/2]

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

Definition at line 1387 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 1334 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;
  }else{
    return true;
  }
}

References G4ThreadLocal.

Referenced by GetNextEdgeIndeces().

GetNextFacet()

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

Definition at line 1500 of file HepPolyhedron.cc.

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

References G4ThreadLocal, CLHEP::detail::n, and geant4_check_module_cycles::nodes.

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), and std::hash< G4Polyhedron >::operator()().

GetNextNormal()

G4bool HepPolyhedron::GetNextNormal

(

G4Normal3D &

normal

)

const

Definition at line 1580 of file HepPolyhedron.cc.

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

References G4ThreadLocal, and CLHEP::normal().

Referenced by G4HepRepFileSceneHandler::AddPrimitive().

GetNextUnitNormal()

G4bool HepPolyhedron::GetNextUnitNormal

(

G4Normal3D &

normal

)

const

Definition at line 1601 of file HepPolyhedron.cc.

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

References CLHEP::normal().

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 1284 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 1302 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
  }else{
    ++iNode;
    return true;                 // not last node
  }
}

References G4ThreadLocal, and CLHEP::normal().

GetNextVertexIndex()

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

Definition at line 1237 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
  }else{
    ++iQVertex;
    return true;  // not Last Edge
  }
}

References G4ThreadLocal.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive().

GetNoFacets()

G4int HepPolyhedron::GetNoFacets ( ) const

inline

Definition at line 294 of file HepPolyhedron.h.

{ return nface; }

References nface.

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), Geant4_SoPolyhedron::computeBBox(), G4CutTubs::CreatePolyhedron(), G4PhysicalVolumeModel::DescribeSolid(), Geant4_SoPolyhedron::generateAlternateRep(), and Geant4_SoPolyhedron::generatePrimitives().

GetNormal()

G4Normal3D HepPolyhedron::GetNormal

(

G4int

iFace

)

const

Definition at line 1530 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 291 of file HepPolyhedron.h.

{ return nvert; }  // Old spelling.

References nvert.

GetNoVertices()

G4int HepPolyhedron::GetNoVertices ( ) const

inline

Definition at line 290 of file HepPolyhedron.h.

{ return nvert; }

References nvert.

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

GetNumberOfRotationSteps()

G4int HepPolyhedron::GetNumberOfRotationSteps ( )

static

Definition at line 248 of file HepPolyhedron.cc.

{
  return fNumberOfRotationSteps;
}

References fNumberOfRotationSteps.

Referenced by G4TwistedTubs::CreatePolyhedron(), G4VTwistedFaceted::CreatePolyhedron(), G4ArrowModel::G4ArrowModel(), G4ViewParameters::G4ViewParameters(), G4ReflectedSolid::GetPolyhedron(), G4BooleanSolid::GetPolyhedron(), G4DisplacedSolid::GetPolyhedron(), G4MultiUnion::GetPolyhedron(), G4ScaledSolid::GetPolyhedron(), G4CSGSolid::GetPolyhedron(), G4Ellipsoid::GetPolyhedron(), G4EllipticalCone::GetPolyhedron(), G4EllipticalTube::GetPolyhedron(), G4GenericTrap::GetPolyhedron(), G4Hype::GetPolyhedron(), G4Paraboloid::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 1617 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.;
}

References nface, pF, and pV.

GetUnitNormal()

G4Normal3D HepPolyhedron::GetUnitNormal

(

G4int

iFace

)

const

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

GetVertex()

G4Point3D HepPolyhedron::GetVertex

(

G4int

index

)

const

Definition at line 1264 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 1639 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.;
}

References nface, pF, and pV.

intersect()

HepPolyhedron HepPolyhedron::intersect

(

const HepPolyhedron &

p

)

const

Definition at line 2803 of file HepPolyhedron.cc.

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

References processor.

InvertFacets()

void HepPolyhedron::InvertFacets ( )

protected

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

References G4Facet::edge, G4Facet::G4Edge::f, nface, pF, and G4Facet::G4Edge::v.

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

operator=() [1/2]

HepPolyhedron & HepPolyhedron::operator=

(

const HepPolyhedron &

from

)

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

References AllocateMemory(), nface, nvert, pF, and pV.

operator=() [2/2]

HepPolyhedron & HepPolyhedron::operator=

(

HepPolyhedron &&

from

)

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

References nface, nvert, pF, and pV.

ResetNumberOfRotationSteps()

void HepPolyhedron::ResetNumberOfRotationSteps ( )

static

Definition at line 283 of file HepPolyhedron.cc.

{
  fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS;
}

References DEFAULT_NUMBER_OF_STEPS, and fNumberOfRotationSteps.

Referenced by G4PhysicalVolumeModel::DescribeSolid(), and 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 475 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) ? true : false;
  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 ? false : true; // 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;
  }
}

References AllocateMemory(), GetNumberOfRotationSteps(), nface, perMillion, pF, pV, RotateEdge(), SetSideFacets(), spatialTolerance, and twopi.

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 750 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) ? true : false;
  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 = 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
 
  G4double *r = new G4double[Nrz];
  G4double *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 -= (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
 
  G4int *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 = 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;
  }
}

References AllocateMemory(), GetNumberOfRotationSteps(), nface, perMillion, pF, pV, RotateEdge(), SetSideFacets(), spatialTolerance, TriangulatePolygon(), and twopi.

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 342 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);
    }
  }
}

References pF.

Referenced by RotateAroundZ(), and RotateContourAroundZ().

SetNumberOfRotationSteps()

void HepPolyhedron::SetNumberOfRotationSteps ( G4int  n )

static

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

References fNumberOfRotationSteps, and CLHEP::detail::n.

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

SetReferences()

void HepPolyhedron::SetReferences ( )

protected

Definition at line 1037 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] = 0;
  }
  freeList = edgeList;
  for (i=0; i<2*nface-1; i++) {
    edgeList[i].next = &edgeList[i+1];
  }
  edgeList[2*nface-1].next = 0;
 
  //   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 == 0) {
        headList[k1] = freeList;
        if (!freeList) {
          std::cerr
          << "Polyhedron::SetReferences: bad link "
          << std::endl;
          break;
        }
        freeList = freeList->next;
        cur = headList[k1];
        cur->next = 0;
        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 == 0) {
          prev->next = freeList;
          if (!freeList) {
            std::cerr
            << "Polyhedron::SetReferences: bad link "
            << std::endl;
            break;
          }
          freeList = freeList->next;
          cur = prev->next;
          cur->next = 0;
          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] != 0) {
      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;
}

References G4Facet::edge, G4Facet::G4Edge::f, nface, nvert, pF, and G4Facet::G4Edge::v.

Referenced by createPolyhedron(), HepPolyhedronCons::HepPolyhedronCons(), HepPolyhedronEllipsoid::HepPolyhedronEllipsoid(), HepPolyhedronEllipticalCone::HepPolyhedronEllipticalCone(), HepPolyhedronHype::HepPolyhedronHype(), HepPolyhedronHyperbolicMirror::HepPolyhedronHyperbolicMirror(), HepPolyhedronParaboloid::HepPolyhedronParaboloid(), HepPolyhedronPgon::HepPolyhedronPgon(), HepPolyhedronSphere::HepPolyhedronSphere(), HepPolyhedronTorus::HepPolyhedronTorus(), 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 404 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);
  }
}

References perMillion, pF, and pi.

Referenced by RotateAroundZ(), and RotateContourAroundZ().

subtract()

HepPolyhedron HepPolyhedron::subtract

(

const HepPolyhedron &

p

)

const

Definition at line 2818 of file HepPolyhedron.cc.

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

References processor.

Transform()

HepPolyhedron & HepPolyhedron::Transform

(

const G4Transform3D &

t

)

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

References HepGeom::BasicVector3D< T >::cross(), InvertFacets(), nvert, and pV.

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

TriangulatePolygon()

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

protected

Definition at line 907 of file HepPolyhedron.cc.

{
  result.resize(0);
  G4int n = 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
  //
  G4int* 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;
}

References CheckSnip(), and CLHEP::detail::n.

Referenced by RotateContourAroundZ().

Friends And Related Function Documentation

operator<<

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

friend

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

Field Documentation

fNumberOfRotationSteps

G4ThreadLocal G4int HepPolyhedron::fNumberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS

staticprotected

Definition at line 217 of file HepPolyhedron.h.

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

nface

G4int HepPolyhedron::nface

protected

Definition at line 218 of file HepPolyhedron.h.

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

nvert

G4int HepPolyhedron::nvert

protected

Definition at line 218 of file HepPolyhedron.h.

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

pF

G4Facet* HepPolyhedron::pF

protected

Definition at line 220 of file HepPolyhedron.h.

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

pV

G4Point3D* HepPolyhedron::pV

protected

Definition at line 219 of file HepPolyhedron.h.

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

---

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

• source/graphics_reps/include/HepPolyhedron.h
• source/graphics_reps/src/HepPolyhedron.cc